src/verify_event.c

   1 /*MIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDI
   2
   3                            P L A Y U M I D I
   4                   (/dev/umixiX.Y Direct MIDI Player)
   5
   6    Copyright(C) 2014 Koine Yuusuke(koinec). All rights reserved.
   7
   8 Redistribution and use in source and binary forms, with or without
   9 modification, are permitted provided that the following conditions are met:
  10
  11  1. Redistributions of source code must retain the above copyright notice,
  12     this list of conditions and the following disclaimer.
  13  2. Redistributions in binary form must reproduce the above copyright
  14     notice, this list of conditions and the following disclaimer in the
  15     documentation and/or other materials provided with the distribution.
  16
  17 THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
  18 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  27 OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 MIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDIMIDI*/
  30
  31
  32 #include<stdio.h>
  33 #include<stdlib.h>
  34 #include<string.h>
  35 #include<assert.h>
  36 #include"playumidi.h"
  37
  38 /* ===================================================================*/
  39 int     EncodeValue(
  40                 Byte    *pb_value,
  41                 DWord   dw_delta )      {
  42
  43         Byte    b_temp;
  44         Byte    b_data[4];
  45         int             i_len;
  46         int             i_cnt;
  47         *(pb_value + 0) = 0x00;
  48         *(pb_value + 1) = 0x00;
  49         *(pb_value + 2) = 0x00;
  50         *(pb_value + 3) = 0x00;
  51
  52         i_len   = 0;
  53         do      {
  54                 b_temp          = (Byte)(dw_delta & 0x0000007f);
  55                 dw_delta        >>= 7;
  56                 if( 0 < i_len ) { b_temp |= 0x80; }
  57
  58                 b_data[i_len++] = b_temp;
  59
  60         }while( dw_delta != 0x00000000 );
  61
  62         for( i_cnt = 0; i_cnt < i_len; i_cnt++ )        {
  63                 *(pb_value + i_cnt)     = b_data[ i_len - i_cnt - 1 ];
  64         }
  65
  66         return i_len;
  67 }
  68
  69
  70 /* ===================================================================*/
  71 int     Veryfy_Event(
  72                 TrackInfo       *p_track_start,
  73                 Word            uw_tracks )     {
  74
  75         int                             i_track;
  76         DWord                   dw_delta;
  77         DWord                   dw_temp;
  78         DWord                   dw_max_events;
  79         MidiEventInfo   *p_mevent;
  80         Byte                    *pb_vartop;
  81         Byte                    *pb_vardata;
  82         Byte                    b_value[4];
  83         Byte                    b_status;
  84         Byte                    *pb_temp;
  85         TrackInfo               *p_track;
  86         int                             i_len;
  87         int                             i_result;
  88
  89
  90         p_mevent                = MidiEvent_GetMidiEventPointer();
  91         assert( NULL != p_mevent );
  92
  93         pb_vartop               = MidiEvent_GetVarDataPointer();
  94         assert( NULL != pb_vartop );
  95         pb_vardata              = pb_vartop;
  96
  97         dw_max_events   = MidiEvent_GetMidiEvents();
  98
  99         /* Init TrackInfo */
 100         for( i_track = 0; i_track < uw_tracks; i_track++ )      {
 101                 p_track         = (p_track_start + i_track);
 102                 assert( NULL != p_track );
 103
 104                 p_track->pb_now                 = p_track->pb_data;
 105                 p_track->dw_delta_now   = 0;
 106         }
 107
 108
 109         for( ; dw_max_events > 0; dw_max_events-- )     {
 110
 111                 /* Encode Delta time */
 112                 dw_delta        = p_mevent->dw_delta;
 113                 for( i_track = 0; i_track < uw_tracks; i_track++ )      {
 114                         p_track         = (p_track_start + i_track);
 115                         p_track->dw_delta_now   += dw_delta;
 116                 }
 117
 118                 /* Get Current TrackID */
 119                 i_track         = (int)p_mevent->uw_track;
 120                 p_track         = (p_track_start + i_track);
 121                 assert( NULL != p_track );
 122
 123                 /* Verify DeltaTime */
 124                 i_len   = EncodeValue( b_value, p_track->dw_delta_now );
 125                 if( 0 == i_len )        {
 126                         fprintf(stderr, "Error!!: Fail Verify MidiEvent --"     \
 127                                                 " [Trk %d] DeltaTime Length = 0\n",
 128                                                 i_track );
 129                         return 0x01;
 130                 }
 131
 132                 i_result        = memcmp( b_value, p_track->pb_now, i_len );
 133                 if( 0 != i_result )     {
 134                         DecodeValue( &dw_temp, p_track->pb_now );
 135                         fprintf(stderr, "Error!!: Fail Verify MidiEvent --"     \
 136                                                 " [Trk %d] DeltaTime: Event:%d(%x %x %x %x) <=> MidiSrc:%d \n",
 137                                                 i_track, i_len, b_value[0], b_value[1],
 138                                                 b_value[2], b_value[3], dw_temp );
 139                         return 0x02;
 140                 }
 141
 142                 p_track->dw_delta_now   = 0;
 143                 p_track->pb_now                 += i_len;
 144
 145                 /* Verify MidiEvent */
 146                 b_status        = p_mevent->b_data[0] & 0xf0;
 147
 148                 if( (SMF_EVENT_NOTEOFF == b_status ) || ( SMF_EVENT_NOTEON == b_status ) ||
 149                                 ( SMF_EVENT_KEYPRESSER == b_status ) || ( SMF_EVENT_CTRLCHANGE == b_status ) ||
 150                                 ( SMF_EVENT_PITCHBEND == b_status ) )   {
 151
 152                         if( 0x00 != p_mevent->b_run_status )    {
 153                                 b_value[0]      = p_mevent->b_data[1];
 154                                 b_value[1]      = p_mevent->b_data[2];
 155                                 i_len           = 2;
 156                         } else  {
 157                                 b_value[0]      = p_mevent->b_data[0];
 158                                 b_value[1]      = p_mevent->b_data[1];
 159                                 b_value[2]      = p_mevent->b_data[2];
 160                                 i_len           = 3;
 161
 162                         }
 163
 164                         i_result        = memcmp( b_value, p_track->pb_now, i_len );
 165                         if( 0 != i_result )             {
 166                                 fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 167                                                 " [Trk %d] 3Byte-Event: Event:%x %x %x <=> MidiSrc:%ld \n",
 168                                                 i_track, b_value[0], b_value[1], b_value[2],
 169                                                 (p_track->pb_data - p_track->pb_now) );
 170                                 return 0x03;
 171                         }
 172
 173                         p_track->pb_now         +=  i_len;
 174                 }
 175                 else if( ( SMF_EVENT_PROGCHANGE == b_status ) ||
 176                                 ( SMF_EVENT_CHNPRESSER == b_status ))           {
 177
 178                         if( 0x00 != p_mevent->b_run_status )    {
 179                                 b_value[0]      = p_mevent->b_data[1];
 180                                 i_len           = 1;
 181                         } else  {
 182                                 b_value[0]      = p_mevent->b_data[0];
 183                                 b_value[1]      = p_mevent->b_data[1];
 184                                 i_len           = 2;
 185
 186                         }
 187
 188                         i_result        = memcmp( b_value, p_track->pb_now, i_len );
 189                         if( 0 != i_result )             {
 190                                 fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 191                                                 " [Trk %d] 2Byte-Event: Event:%x %x <=> MidiSrc:%ld \n",
 192                                                 i_track, b_value[0], b_value[1],
 193                                                 (p_track->pb_data - p_track->pb_now) );
 194                                 return 0x04;
 195                         }
 196
 197                         p_track->pb_now         +=  i_len;
 198                 }
 199                 else if( SMF_EVENT_SYSEX_META == b_status )     {
 200
 201                         b_status        = p_mevent->b_data[0];
 202                         if( SMF_EVENT_SYSEX_F0 == b_status )    {
 203
 204                                 /* Check 1Byte */
 205                                 if( p_mevent->b_data[0] != *p_track->pb_now )           {
 206                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 207                                                 " [Trk %d] SysEx(F0) Status: Code:%x <=> MidiSrc:%ld \n",
 208                                                 i_track, p_mevent->b_data[0], (p_track->pb_data - p_track->pb_now) );
 209                                         return 0x05;
 210                                 }
 211                                 p_track->pb_now++;
 212
 213                                 /* Check Length */
 214                                 i_len   = EncodeValue( b_value, (p_mevent->dw_length - 1) );
 215                                 i_result        = memcmp( b_value, p_track->pb_now, i_len );
 216                                 if( 0 != i_result )             {
 217                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 218                                                 " [Trk %d] SysEx(F0) Size: Code:%d(%x %x %x %x)<=> MidiSrc:%ld \n",
 219                                                 i_track, p_mevent->dw_length, b_value[0], b_value[1], b_value[2],
 220                                                 b_value[3], (p_track->pb_data - p_track->pb_now) );
 221                                         return 0x05;
 222                                 }
 223                                 p_track->pb_now         +=  i_len;
 224
 225                                 pb_temp = (pb_vartop + p_mevent->dw_dataptr);
 226                                 if( pb_temp != pb_vardata )             {
 227                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 228                                                 " [Trk %d] SysEx(F0) VarData Ptr. Error \n", i_track );
 229                                         return 0x06;
 230                                 }
 231
 232                                 if( p_mevent->b_data[0] != *pb_temp )   {
 233                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 234                                                 " [Trk %d] SysEx(F0) Data: First Byte(%x,%x) \n",
 235                                                 i_track, p_mevent->b_data[0], *(p_track->pb_now) );
 236                                         return 0x0f;
 237
 238                                 }
 239                                 pb_temp++;
 240
 241                                 i_result        = memcmp( pb_temp, p_track->pb_now, p_mevent->dw_length - 1 );
 242                                 if( 0 != i_result )             {
 243                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 244                                                 " [Trk %d] SysEx(F0) Data: len=%d \n", i_track, i_len );
 245                                         return 0x07;
 246                                 }
 247
 248                                 p_track->pb_now         += (p_mevent->dw_length - 1);
 249                                 pb_vardata                      += p_mevent->dw_length;
 250
 251                         } else if( SMF_EVENT_SYSEX_F7 == b_status )             {
 252
 253                                 /* Check 1Byte */
 254                                 if( p_mevent->b_data[0] != *p_track->pb_now )           {
 255                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 256                                                 " [Trk %d] SysEx(F7) Status: Code:%x <=> MidiSrc:%ld \n",
 257                                                 i_track, p_mevent->b_data[0], (p_track->pb_data - p_track->pb_now) );
 258                                         return 0x08;
 259                                 }
 260                                 p_track->pb_now++;
 261
 262                                 /* Check Length */
 263                                 i_len   = EncodeValue( b_value, p_mevent->dw_length );
 264                                 i_result        = memcmp( b_value, p_track->pb_now, i_len );
 265                                 if( 0 != i_result )             {
 266                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 267                                                 " [Trk %d] SysEx(F7) Size: Code:%d(%x %x %x %x)<=> MidiSrc:%ld \n",
 268                                                 i_track, p_mevent->dw_length, b_value[0], b_value[1], b_value[2],
 269                                                 b_value[3], (p_track->pb_data - p_track->pb_now) );
 270                                         return 0x08;
 271                                 }
 272                                 p_track->pb_now         +=  i_len;
 273
 274                                 pb_temp = (pb_vartop + p_mevent->dw_dataptr);
 275                                 if( pb_temp != pb_vardata )             {
 276                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 277                                                 " [Trk %d] SysEx(F7) VarData Ptr. Error \n", i_track );
 278                                         return 0x08;
 279                                 }
 280
 281                                 i_result        = memcmp( pb_temp, p_track->pb_now, p_mevent->dw_length );
 282                                 if( 0 != i_result )             {
 283                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 284                                                 " [Trk %d] SysEx(F7) Data: len=%d \n", i_track, i_len );
 285                                         return 0x09;
 286                                 }
 287
 288                                 p_track->pb_now         += p_mevent->dw_length;
 289                                 pb_vardata                      += p_mevent->dw_length;
 290
 291                         } else if( SMF_EVENT_META == b_status )         {
 292
 293                                 /* Check 1Byte */
 294                                 if( p_mevent->b_data[0] != *(p_track->pb_now + 0) )             {
 295                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 296                                                 " [Trk %d] Meta Status: Code:%x <=> MidiSrc:%x \n",
 297                                                 i_track, p_mevent->b_data[0], *p_track->pb_now );
 298                                         return 0x08;
 299                                 }
 300
 301                                 /* Check 2Byte */
 302                                 if( p_mevent->b_data[1] != *(p_track->pb_now + 1) )             {
 303                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 304                                                 " [Trk %d] Meta Code: Code:%x <=> MidiSrc:%ld \n",
 305                                                 i_track, p_mevent->b_data[1], (p_track->pb_data - p_track->pb_now) );
 306                                         return 0x08;
 307                                 }
 308
 309                                 /* Check Length */
 310                                 i_len   = DecodeValue( &dw_temp, (p_track->pb_now + 2) );
 311
 312                                 i_len   = EncodeValue( b_value, (p_mevent->dw_length - i_len - 2) );
 313                                 i_result        = memcmp( b_value, (p_track->pb_now + 2), i_len );
 314                                 if( 0 != i_result )             {
 315                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 316                                                 " [Trk %d] Meta Size: Code:%d(%x %x %x %x)<=> MidiSrc:%ld \n",
 317                                                 i_track, p_mevent->dw_length, b_value[0], b_value[1], b_value[2],
 318                                                 b_value[3], (p_track->pb_data - p_track->pb_now) );
 319                                         return 0x08;
 320                                 }
 321
 322                                 pb_temp = (pb_vartop + p_mevent->dw_dataptr);
 323                                 if( pb_temp != pb_vardata )             {
 324                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 325                                                 " [Trk %d] Meta VarData Ptr. Error \n", i_track );
 326                                         return 0x08;
 327                                 }
 328
 329                                 i_result        = memcmp( pb_temp, p_track->pb_now, p_mevent->dw_length );
 330                                 if( 0 != i_result )             {
 331                                         fprintf( stderr, "Error!!: Fail Verify MidiEvent --"    \
 332                                                 " [Trk %d] Meta Data: len=%d \n", i_track, i_len );
 333                                         return 0x09;
 334                                 }
 335
 336                                 p_track->pb_now         += p_mevent->dw_length;
 337                                 pb_vardata                      += p_mevent->dw_length;
 338
 339                         }
 340                 }
 341
 342                 p_mevent++;
 343         }
 344
 345         fputs( "Verify MidiEvent is Completed!!\n", stderr );
 346
 347         return 0x00;
 348 }
 349
 350
 351 /* EOF of verify_event.c **********************************************/