Error Corrections

Author: pschatzmann

.gitignore

@@ -1,2 +1,2 @@
 .vscode
-/build
+build/

examples/parse/CMakeLists.txt renamed to examples/midi-parse/CMakeLists.txt

@@ -4,15 +4,16 @@ cmake_minimum_required(VERSION 3.20)
 project(midi-parse)
 set (CMAKE_CXX_STANDARD 11)
 set (DCMAKE_CXX_FLAGS "-Werror")
+set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")
 
 # Build with library
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
     add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../.. ${CMAKE_CURRENT_BINARY_DIR}/midi-file )
 endif()
 
 # build sketch as executable
-SET_SOURCE_FILES_PROPERTIES(parse.ino PROPERTIES LANGUAGE CXX)
-add_executable (midi-parse parse.ino ../main.cpp)
+SET_SOURCE_FILES_PROPERTIES(midi-parse.ino PROPERTIES LANGUAGE CXX)
+add_executable (midi-parse midi-parse.ino ../main.cpp)
 
 # specify libraries
 target_link_libraries(midi-parse midi-file)

examples/parse/example-midi.h renamed to examples/midi-parse/example-midi.h

@@ -5,33 +5,49 @@
 const int write_size = 256;
 MidiFile mf;
 int pos = 0;
+bool debug = false;
 
 void setup() {
 #ifdef ARDUINO
   Serial.begin(19200);
 #endif
-  mf.begin(false,  256*5);
+  mf.begin(debug, 256 * 5);
 }
 
 void loop() {
+  if (!mf) return;
 
   // try to keep buffer filled
   if (mf.availableForWrite() > write_size) {
     int len = std::min(write_size, (int)example_mid_len - len);
-    mf.write(example_mid + pos, len);
+    if (pos < example_mid_len) {
+      mf.write(example_mid + pos, len);
+    } else {
+      // when there is no more data we let the parser know
+      mf.end();
+    }
     pos += 256;
   }
 
   // parse midi
   auto state = mf.parse();
-  if (state.status == MIDI_PARSER_TRACK_MIDI) {
+  switch (state.status)
+  case MIDI_PARSER_TRACK_MIDI: {
     // process midi
     printf("process");
     printf("  time: %ld", (long)state.vtime);
     printf("  status: %d [%s]", state.midi.status,
            mf.midi_status_name(state.midi.status));
     printf("  channel: %d", state.midi.channel);
     printf("  param1: %d", state.midi.param1);
-    printf("  param2: %d", state.midi.param2);
+    printf("  param2: %d\n", state.midi.param2);
+    break;
+  case MIDI_PARSER_ERROR:
+    printf("Error\n");
+  case MIDI_PARSER_EOB:
+#ifndef ARDUINO
+    exit(-1);
+#endif
+    break;
   }
 }

examples/parse/parse.ino renamed to examples/midi-parse/midi-parse.ino

@@ -18,7 +18,7 @@
 #include "MidiFileCommon.h"
 
 #define MIDI_BUFFER_SIZE 1024 * 2
-
+#define MIDI_MIN_REFILL_SIZE 512 
 /**
  * @brief Midi File parser. Provide the data via write: You should try to keep
  * the buffer as full as possible while parsing. You get the next parsing result
@@ -29,8 +29,8 @@ class MidiFile {
 public:
   bool begin(bool log = true, int bufferSize = MIDI_BUFFER_SIZE) {
     log_active = log;
-    has_more_data = true;
     parser_state.in.resize(bufferSize);
+    is_ok = true;
     reset();
     return true;
   }
@@ -39,9 +39,7 @@ class MidiFile {
     // store actual processing length
     if (len > 0) {
       write_len = len;
-    } else {
-      has_more_data = false;
-    }
+    } 
     // write only if data is available
     if (len < parser_state.in.availableForWrite()) {
       return parser_state.in.write(data, len);
@@ -52,27 +50,28 @@ class MidiFile {
   int availableForWrite() { return parser_state.in.availableForWrite(); }
 
   /// Parse and provide next midi element
-  midi_parser_state parse() {
-    // make sure that we do not run out of data
-    if (parser_state.in.available() < 100 && has_more_data) {
-      printf("MIDI_PARSER_MORE_DATA\n");
-      parser_state.status_result = MIDI_PARSER_MORE_DATA;
-      return parser_state;
-    }
+  midi_parser_state &parse() {
     // parse next element
+    parser_state.status = MIDI_PARSER_EOB;
     if (!parser_state.in.isEmpty()) {
       midi_parser_status status = midi_parse();
-      parser_state.status_result = status;
+      parser_state.status = status;
       if (log_active) {
         logStatus(status);
       }
     }
+    // 
+    if (parser_state.status == MIDI_PARSER_EOB || parser_state.status == MIDI_PARSER_ERROR ){
+      is_ok = false;
+    }
     return parser_state;
   }
 
+  operator bool() {
+    return is_ok;
+  }
+
   void end() {
-    reset();
-    has_more_data = false;
   }
 
   const char *midi_status_name(int status) {
@@ -153,7 +152,7 @@ class MidiFile {
   bool log_active = false;
   int write_len = 256;
   midi_parser_state parser_state;
-  bool has_more_data = true;
+  bool is_ok = true;
 
   void logStatus(midi_parser_status status) {
     switch (status) {
@@ -166,11 +165,11 @@ class MidiFile {
       break;
 
     case MIDI_PARSER_INIT:
-      printf("MIDI_PARSER_INIT");
+      printf("MIDI_PARSER_INIT\n");
       break;
 
     case MIDI_PARSER_HEADER:
-      printf("header\n");
+      printf("\nheader\n");
       printf("  size: %d\n", parser_state.header.size);
       printf("  format: %d [%s]\n", parser_state.header.format,
              midi_file_format_name(parser_state.header.format));
@@ -179,12 +178,12 @@ class MidiFile {
       break;
 
     case MIDI_PARSER_TRACK:
-      printf("track\n");
+      printf("\ntrack\n");
       printf("  length: %d\n", parser_state.track.size);
       break;
 
     case MIDI_PARSER_TRACK_MIDI:
-      printf("track-midi\n");
+      printf("\ntrack-midi\n");
       printf("  time: %ld\n", (long)parser_state.vtime);
       printf("  status: %d [%s]\n", parser_state.midi.status,
              midi_status_name(parser_state.midi.status));
@@ -194,27 +193,28 @@ class MidiFile {
       break;
 
     case MIDI_PARSER_TRACK_META:
-      printf("track-meta\n");
+      printf("\ntrack-meta\n");
       printf("  time: %ld\n", (long)parser_state.vtime);
       printf("  type: %d [%s]\n", parser_state.meta.type,
              midi_meta_name(parser_state.meta.type));
       printf("  length: %d\n", parser_state.meta.length);
       break;
 
     case MIDI_PARSER_TRACK_SYSEX:
-      printf("track-sysex\n");
+      printf("\ntrack-sysex\n");
       printf("  time: %ld\n", (long)parser_state.vtime);
       break;
 
     default:
-      printf("unhandled state: %d\n", status);
+      printf("\nunhandled state: %d\n", status);
       break;
     }
   }
 
   void reset() {
     parser_state.in.reset();
     parser_state.status = MIDI_PARSER_INIT;
+    parser_state.status_internal = MIDI_PARSER_INIT;
   }
 
   int midi_event_datalen(int status) {
@@ -251,7 +251,7 @@ class MidiFile {
     if (parser_state.in.available() < 14)
       return MIDI_PARSER_EOB;
 
-    if (parser_state.in.equals("MThd"))
+    if (!parser_state.in.equals("MThd"))
       return MIDI_PARSER_ERROR;
 
     parser_state.header.size = midi_parse_be32(parser_state.in.peekStr(4, 4));
@@ -262,7 +262,7 @@ class MidiFile {
         midi_parse_be16(parser_state.in.peekStr(12, 1));
 
     parser_state.in.consume(14);
-    parser_state.status = MIDI_PARSER_HEADER;
+    parser_state.status_internal = MIDI_PARSER_HEADER;
     return MIDI_PARSER_HEADER;
   }
 
@@ -271,7 +271,7 @@ class MidiFile {
       return MIDI_PARSER_EOB;
 
     parser_state.track.size = midi_parse_be32(parser_state.in.peekStr(0, 4));
-    parser_state.status = MIDI_PARSER_TRACK;
+    parser_state.status_internal = MIDI_PARSER_TRACK;
     parser_state.in.consume(8);
     // parser.in.available() -= 8;
     parser_state.buffered_status = MIDI_STATUS_NA;
@@ -305,6 +305,10 @@ class MidiFile {
       cont = b & 0x80;
     }
 
+    if (parser_state.in.available()<nbytes){
+      return false;
+    }
+
     parser_state.in.consume(nbytes);
     // parser.in.available() -= nbytes;
     parser_state.track.size -= nbytes;
@@ -441,7 +445,7 @@ class MidiFile {
     if (parser_state.in.isEmpty())
       return MIDI_PARSER_EOB;
 
-    switch (parser_state.status) {
+    switch (parser_state.status_internal) {
     case MIDI_PARSER_INIT:
       return midi_parse_header();
 
@@ -451,7 +455,7 @@ class MidiFile {
     case MIDI_PARSER_TRACK:
       if (parser_state.track.size == 0) {
         // we reached the end of the track
-        parser_state.status = MIDI_PARSER_HEADER;
+        parser_state.status_internal = MIDI_PARSER_HEADER;
         return midi_parse();
       }
       return midi_parse_event();

src/MidiFile.h

@@ -2,7 +2,6 @@
 #include "RingBuffer.h"
 
 enum midi_parser_status {
-  MIDI_PARSER_MORE_DATA = -3,
   MIDI_PARSER_EOB = -2,
   MIDI_PARSER_ERROR = -1,
   MIDI_PARSER_INIT = 0,
@@ -80,8 +79,8 @@ struct midi_sysex_event {
 };
 
 struct midi_parser_state {
-  enum midi_parser_status status_result;
   enum midi_parser_status status;
+  enum midi_parser_status status_internal;
   enum midi_status buffered_status;
   unsigned buffered_channel;
 

src/MidiFileCommon.h

@@ -15,6 +15,11 @@ class RingBuffer {
 public:
   RingBuffer() = default;
 
+  RingBuffer(RingBuffer &t){
+    _aucBuffer = nullptr;
+    reset();
+  }
+
   RingBuffer(int size) {
     resize(size);
     reset();
@@ -135,7 +140,7 @@ class RingBuffer {
 
   /// @brief Removes the next n characters from the ringbuffer
   void consume(int offset) {
-    assert(available() > offset);
+    assert(available() >= offset);
     for (int j = 0; j < offset; j++) {
       read();
     }