rcp_functions.cpp

   1 /*
   2   RCP converter functions
   3
   4   Copyright 1999 by Daisuke Nagano <breeze.nagano@nifty.ne.jp>
   5   Mar.11.1999
   6   Oct.16.2002
   7
   8
   9   Permission is hereby granted, free of charge, to any person obtaining a copy
  10   of this software and associated documentation files (the "Software"), to deal
  11   in the Software without restriction, including without limitation the rights
  12   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13   copies of the Software, and to permit persons to whom the Software is
  14   furnished to do so, subject to the following conditions:
  15
  16   The above copyright notice and this permission notice shall be included in
  17   all copies or substantial portions of the Software.
  18
  19   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  22   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25   THE SOFTWARE.
  26 */
  27
  28 /* ------------------------------------------------------------------- */
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif /* HAVE_CONFIG_H */
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35
  36 #include "rcp.h"
  37 #include "rcp_functions.h"
  38 #include "smf.h"
  39
  40 /* ------------------------------------------------------------------- */
  41
  42 /*
  43   Each functions return 0 if processing succeed.
  44
  45   The result of processing will be stored in the member of structure
  46   RCP_DATA. It is available in
  47
  48       int ((RCP_DATA)rcp).result_smf[]
  49
  50   The result SMF data will be stored with the terminater SMF_TERM.
  51   The max size of result_smf[] is RCP_MAX_RESULT_SMF.
  52   */
  53
  54 /* ------------------------------------------------------------------- */
  55
  56 int rcp_note_on(RCP_DATA *rcp, int track ) {
  57
  58   int note, vel;
  59
  60   note = rcp->track[track].event;
  61   vel  = rcp->track[track].vel;
  62
  63   if ( vel != 0 && rcp->track[track].gate != 0 &&
  64        rcp->track[track].enabled == FLAG_TRUE ) {
  65
  66     if ( note > 127 || note < 0 ) {
  67       /* invalid note number */
  68       return 1;
  69     }
  70     if ( vel > 127 || vel < 0 ) {
  71       /* invalid velocity value */
  72       return 1;
  73     }
  74
  75     if ( rcp->track[track].key != 0x80 )
  76       note = (note+rcp->play_bias+rcp->track[track].key)%128;
  77     if ( note < 0 ) note=0;
  78     if ( note >127) note=127;
  79
  80     if ( rcp->track[track].notes[note] == 0 ) {
  81       rcp->result_smf[0] = MIDI_NOTEON + rcp->track[track].midi_ch;
  82       rcp->result_smf[1] = note;
  83       rcp->result_smf[2] = vel;
  84       rcp->result_smf[3] = SMF_TERM;
  85     }
  86
  87     rcp->track[track].notes[note] = rcp->track[track].gate;
  88
  89     if ( rcp->track[track].notes_min > note )
  90       rcp->track[track].notes_min = note;
  91     if ( rcp->track[track].notes_max < note )
  92       rcp->track[track].notes_max = note;
  93
  94     rcp->track[track].all_notes_expired = FLAG_FALSE;
  95   }
  96
  97   return 0;
  98 }
  99
 100 int rcp_note_off(RCP_DATA *rcp, int track, int note ) {
 101
 102   int n;
 103
 104   rcp->result_smf[0] = MIDI_NOTEOFF + rcp->track[track].midi_ch;
 105   rcp->result_smf[1] = note;
 106   rcp->result_smf[2] = 0;
 107   rcp->result_smf[3] = SMF_TERM;
 108
 109   if ( rcp->track[track].notes_min == note ) {
 110     /* Was I the lowest note ? */
 111     for ( n=note+1 ; n<=rcp->track[track].notes_max ; n++ ) {
 112       if ( rcp->track[track].notes[n]==0 ) continue;
 113       rcp->track[track].notes_min = n;
 114       break;
 115     }
 116     if ( rcp->track[track].notes_min == note )
 117       rcp->track[track].notes_min = 127;
 118   }
 119
 120   if ( rcp->track[track].notes_max == note ) {
 121     /* Was I the highest note ? */
 122     for  ( n=note-1 ; n>=rcp->track[track].notes_min ; n-- ) {
 123       if ( rcp->track[track].notes[n]==0 ) continue;
 124       rcp->track[track].notes_max = n;
 125       break;
 126     }
 127     if ( rcp->track[track].notes_max == note )
 128       rcp->track[track].notes_max = 0;
 129   }
 130
 131   if ( rcp->track[track].notes_min == 127 &&
 132        rcp->track[track].notes_max == 0 ) {
 133     /* All notes expired. */
 134     rcp->track[track].all_notes_expired = FLAG_TRUE;
 135   }
 136
 137   return 0;
 138 }
 139
 140 int rcp_user_exclusive(RCP_DATA *rcp, int track ){
 141
 142   int id;
 143   int v1,v2;
 144   int i,j,d,r;
 145   int size,check_sum;
 146   int finished;
 147
 148   id = rcp->track[track].event - 0x90;
 149   v1 = rcp->track[track].gate;
 150   v2 = rcp->track[track].vel;
 151   if ( id < 0 || id > 7 ) {
 152     /* Invalid number of user exclusive id */
 153     return 1;
 154   }
 155   if ( v1 > 127 || v1 < 0 ) {
 156     /* invalid value of user exclusive */
 157     return 1;
 158   }
 159   if ( v2 > 127 || v2 < 0 ) {
 160     /* invalid value of user exclusive */
 161     return 1;
 162   }
 163
 164   check_sum = 0;
 165   finished = FLAG_FALSE;
 166
 167   size=0;
 168   i=0;
 169   while ( i < RCP_USER_EXCLUSIVE_SIZE &&
 170           rcp->user_exclusive[id][i] != 0xf7 ) {
 171     if ( rcp->user_exclusive[id][i] != 0x83 )
 172       size++;
 173     i++;
 174   }
 175   size++;
 176
 177   rcp->result_smf[0] = 0xf0;
 178   rcp->result_smf[1] = size;
 179   i=0;
 180   j=2;
 181   while ( i<RCP_USER_EXCLUSIVE_SIZE &&
 182           finished == FLAG_FALSE ) {
 183     d = rcp->user_exclusive[id][i++];
 184
 185     switch( d ) {
 186     case 0x80:
 187       r = v1;
 188       break;
 189
 190     case 0x81:
 191       r = v2;
 192       break;
 193
 194     case 0x82:
 195       r = rcp->track[track].midi_ch;
 196       break;
 197
 198     case 0x83:
 199       check_sum = 0;
 200       continue;
 201       break;
 202
 203     case 0x84:
 204       r = 0x80 - (check_sum & 0x7f);
 205       break;
 206
 207     case 0xf7:
 208       r = d;
 209       finished = FLAG_TRUE;
 210       break;
 211
 212     default:
 213       r = d;
 214       break;
 215     }
 216     rcp->result_smf[j++] = r;
 217     check_sum += r;
 218     if ( finished == FLAG_TRUE ) break;
 219   }
 220   if ( i==RCP_USER_EXCLUSIVE_SIZE )
 221     rcp->result_smf[j++] = 0xf7;
 222   rcp->result_smf[j] = SMF_TERM;
 223
 224   return 0;
 225 }
 226
 227 int rcp_ch_exclusive(RCP_DATA *rcp, int track ){
 228
 229   int v1,v2;
 230   int i,j,*l;
 231   int size,check_sum;
 232   int finished;
 233   int ptr;
 234   unsigned char *data = rcp->data;
 235
 236   v1 = rcp->track[track].gate;
 237   v2 = rcp->track[track].vel;
 238   if ( v1 > 127 || v1 < 0 ) {
 239     /* invalid value of user exclusive */
 240     return 1;
 241   }
 242   if ( v2 > 127 || v2 < 0 ) {
 243     /* invalid value of user exclusive */
 244     return 1;
 245   }
 246
 247   ptr = rcp->track[track].current_ptr+4;
 248   size=0;
 249   while ( data[ptr+0] == RCP_2ND_EVENT ) {
 250     if ( data[ptr+2]==0xf7 ) size++;
 251     else size+=2;
 252     if ( data[ptr+2] == 0x83 ) size--;
 253     if ( data[ptr+3] == 0x83 ) size--;
 254     ptr+=4;
 255   }
 256   l = smf_number_conversion((long)size);
 257
 258   ptr = rcp->track[track].current_ptr+4;
 259   j=0;
 260   check_sum = 0;
 261   finished = FLAG_FALSE;
 262
 263   rcp->result_smf[j++] = 0xf0;
 264   i=0;
 265   do {
 266     rcp->result_smf[j++] = l[i];
 267   } while ( l[i++] >= 0x80 );
 268
 269   while ( finished == FLAG_FALSE ) {
 270     int d[2],r;
 271     int i;
 272
 273     if ( data[ptr+0] != RCP_2ND_EVENT ) break;
 274
 275     d[0] = data[ptr+2];
 276     d[1] = data[ptr+3];
 277     ptr += 4;
 278
 279     for ( i=0 ; i<2 ; i++ ) {
 280       switch( d[i] ) {
 281       case 0x80:
 282         r = v1;
 283         break;
 284
 285       case 0x81:
 286         r = v2;
 287         break;
 288
 289       case 0x82:
 290         r = rcp->track[track].midi_ch;
 291         break;
 292
 293       case 0x83:
 294         check_sum = 0;
 295         continue;
 296         break;
 297
 298       case 0x84:
 299         r = 0x80 - (check_sum & 0x7f);
 300         break;
 301
 302       case 0xf7:
 303         r = d[i];
 304         finished = FLAG_TRUE;
 305         break;
 306
 307       default:
 308         r = d[i];
 309         break;
 310       }
 311       rcp->result_smf[j] = r;
 312       check_sum += r;
 313       if ( j < RCP_MAX_RESULT_SMF_SIZE-1 ) j++;
 314       if ( finished == FLAG_TRUE ) break;
 315     }
 316   }
 317   rcp->result_smf[j] = SMF_TERM;
 318   rcp->track[track].current_ptr = ptr-4;
 319
 320   return 0;
 321 }
 322
 323 int rcp_exec_extern_prog(RCP_DATA *rcp, int track ){
 324
 325   /* exec_extern_prog is not supported */
 326
 327   /* skip all 2nd events */
 328   int p;
 329   p = rcp->track[track].current_ptr+4;
 330   while ( rcp->data[p+0] == RCP_2ND_EVENT ) {
 331     p+=4;
 332   }
 333   rcp->track[track].current_ptr = p-4;
 334
 335   return 1;
 336 }
 337
 338 int rcp_bank_and_prog(RCP_DATA *rcp, int track ){
 339   int prog, bank;
 340
 341   prog = rcp->track[track].gate;
 342   bank = rcp->track[track].vel;
 343
 344   if ( prog > 127 || prog < 0 ) {
 345     /* invalid program number */
 346     return 1;
 347   }
 348   if ( bank > 127 || bank < 0 ) {
 349     /* invalid tone bank number */
 350     return 1;
 351   }
 352
 353   rcp->result_smf[0] = MIDI_CONTROL + rcp->track[track].midi_ch;
 354   rcp->result_smf[1] = SMF_CTRL_BANK_SELECT_M;
 355   rcp->result_smf[2] = bank;
 356   rcp->result_smf[3] = 0;        /* step time = 0 */
 357                         /* Should I send SMF_CTRL_BANK_SELECT_L in here ? */
 358   rcp->result_smf[4] = MIDI_PROGRAM + rcp->track[track].midi_ch;
 359   rcp->result_smf[5] = prog;
 360   rcp->result_smf[6] = SMF_TERM;
 361
 362   return 0;
 363 }
 364
 365 int rcp_key_scan(RCP_DATA *rcp, int track ){
 366
 367   /* KeyScan is not supported */
 368   return -1;
 369 }
 370
 371 int rcp_midi_ch_change(RCP_DATA *rcp, int track ){
 372
 373   int ch;
 374   int last_port;
 375
 376   ch = rcp->track[track].gate;
 377
 378   if ( ch > 32 || ch < 0 ) {
 379     /* invalid midi channel number */
 380     return 1;
 381   }
 382
 383   if ( ch == 0 ) {
 384     /* part off */
 385     rcp->track[track].enabled = FLAG_FALSE;
 386     return 0;
 387   }
 388
 389   rcp->track[track].enabled = FLAG_TRUE;
 390   ch--;
 391   last_port = rcp->track[track].port;
 392
 393   if ( ch < 16 ) rcp->track[track].port = 0;
 394   else if ( ch < 32 ) rcp->track[track].port = 1;
 395   /* port 2,3,... will follow */
 396
 397   rcp->track[track].midi_ch = ch%16;
 398
 399 #ifdef ENABLE_PORT_CHANGE
 400   if ( last_port != rcp->track[track].port ) {
 401     rcp->result_smf[0] = MIDI_META;
 402     rcp->result_smf[1] = META_PORT;
 403     rcp->result_smf[2] = 1;      /* a byte follows */
 404     rcp->result_smf[3] = rcp->track[track].port;
 405     rcp->result_smf[4] = SMF_TERM;
 406   }
 407 #endif /* ENABLE_PORT_CHANGE */
 408
 409   return 0;
 410 }
 411
 412 int rcp_tempo_change(RCP_DATA *rcp, int track ){
 413
 414   int t1,t2,t3;
 415   long t;
 416
 417   rcp->realtempo = rcp->tempo * rcp->track[track].gate / 64;
 418   t = 1000 * 1000 * 60 / (rcp->tempo * rcp->track[track].gate / 64);
 419
 420   t1 = (int)((t>>16)&0xff);
 421   t2 = (int)((t>> 8)&0xff);
 422   t3 = (int)(t&0xff);
 423
 424   rcp->result_smf[0] = MIDI_META;
 425   rcp->result_smf[1] = META_TEMPO;
 426   rcp->result_smf[2] = 3;
 427   rcp->result_smf[3] = t1;
 428   rcp->result_smf[4] = t2;
 429   rcp->result_smf[5] = t3;
 430   rcp->result_smf[6] = SMF_TERM;
 431
 432   return 0;
 433 }
 434
 435 int rcp_after_touch(RCP_DATA *rcp, int track ){
 436   int after_touch;
 437
 438   after_touch = rcp->track[track].gate;
 439   if ( after_touch > 127 || after_touch < 0 ) {
 440     /* invalid after touch value */
 441     return 1;
 442   }
 443
 444   rcp->result_smf[0] = MIDI_CHANPRES + rcp->track[track].midi_ch;
 445   rcp->result_smf[1] = after_touch;
 446   rcp->result_smf[2] = SMF_TERM;
 447
 448   return 0;
 449 }
 450
 451 int rcp_control_change(RCP_DATA *rcp, int track ){
 452
 453   int number, val;
 454
 455   number = rcp->track[track].gate;
 456   val    = rcp->track[track].vel;
 457   if ( number > 127 || number < 0 ) {
 458     /* invalid control number */
 459     return 1;
 460   }
 461   if ( val > 127 || val < 0 ) {
 462     /* invalid control value */
 463     return 1;
 464   }
 465
 466   rcp->result_smf[0] = MIDI_CONTROL + rcp->track[track].midi_ch;
 467   rcp->result_smf[1] = number;
 468   rcp->result_smf[2] = val;
 469   rcp->result_smf[3] = SMF_TERM;
 470
 471   return 0;
 472 }
 473
 474 int rcp_program_change(RCP_DATA *rcp, int track ){
 475
 476   int prog;
 477
 478   prog = rcp->track[track].gate;
 479   if ( prog > 127 || prog < 0 ) {
 480     /* invalid program number */
 481     return 1;
 482   }
 483
 484   rcp->result_smf[0] = MIDI_PROGRAM + rcp->track[track].midi_ch;
 485   rcp->result_smf[1] = prog;
 486   rcp->result_smf[2] = SMF_TERM;
 487
 488   return 0;
 489 }
 490
 491 int rcp_after_touch_poly(RCP_DATA *rcp, int track ){
 492
 493   int key, val;
 494
 495   key = rcp->track[track].gate;
 496   val = rcp->track[track].vel;
 497   if ( key > 127 || key < 0 ) {
 498     /* invalid after touch key number */
 499     return 1;
 500   }
 501   if ( val > 127 || val < 0 ) {
 502     /* invalid after touch value */
 503     return 1;
 504   }
 505
 506   rcp->result_smf[0] = MIDI_PRESSURE + rcp->track[track].midi_ch;
 507   rcp->result_smf[1] = key;
 508   rcp->result_smf[2] = val;
 509   rcp->result_smf[3] = SMF_TERM;
 510
 511   return 0;
 512 }
 513
 514 int rcp_pitch_bend(RCP_DATA *rcp, int track ){
 515
 516   int v1, v2;
 517
 518   v1 = rcp->track[track].gate;
 519   v2 = rcp->track[track].vel;
 520   if ( v1 > 127 || v1 < 0 ) {
 521     /* invalid value of pitch bend */
 522     return 1;
 523   }
 524   if ( v2 > 127 || v2 < 0 ) {
 525     /* invalid value of pitch bend */
 526     return 1;
 527   }
 528
 529   rcp->result_smf[0] = MIDI_PITCHB + rcp->track[track].midi_ch;
 530   rcp->result_smf[1] = v1;
 531   rcp->result_smf[2] = v2;
 532   rcp->result_smf[3] = SMF_TERM;
 533
 534   return 0;
 535 }
 536
 537 int rcp_yamaha_base(RCP_DATA *rcp, int track ){
 538
 539   int v1, v2;
 540
 541   v1 = rcp->track[track].gate;
 542   v2 = rcp->track[track].vel;
 543   if ( v1 > 127 || v1 < 0 ) {
 544     /* invalid value of yamaha base */
 545     return 1;
 546   }
 547   if ( v2 > 127 || v2 < 0 ) {
 548     /* invalid value of yamaha base */
 549     return 1;
 550   }
 551
 552   rcp->track[track].yamaha_base[0] = v1;
 553   rcp->track[track].yamaha_base[1] = v2;
 554
 555   return 0;
 556 }
 557
 558 int rcp_yamaha_dev_name(RCP_DATA *rcp, int track ){
 559
 560   int v1, v2;
 561
 562   v1 = rcp->track[track].gate;
 563   v2 = rcp->track[track].vel;
 564   if ( v1 > 127 || v1 < 0 ) {
 565     /* invalid value of yamaha device number */
 566     return 1;
 567   }
 568   if ( v2 > 127 || v2 < 0 ) {
 569     /* invalid value of yamaha device number */
 570     return 1;
 571   }
 572
 573   rcp->yamaha_dev_id   = v1;
 574   rcp->yamaha_model_id = v2;
 575
 576   return 0;
 577 }
 578
 579 int rcp_yamaha_addr(RCP_DATA *rcp, int track ){
 580
 581   int d1,d2;
 582   int a1,a2,a3;
 583   int v;
 584
 585   d1 = rcp->yamaha_dev_id;
 586   d2 = rcp->yamaha_model_id;
 587
 588   a1 = rcp->track[track].yamaha_base[0];
 589   a2 = rcp->track[track].yamaha_base[1];
 590   a3 = rcp->track[track].gate;
 591
 592   v   = rcp->track[track].vel;
 593
 594   if ( v > 127 || v < 0 ) {
 595     /* invalid value of yamaha device number */
 596     return 1;
 597   }
 598   if ( d1 > 127 || d1 < 0 ||
 599        d2 > 127 || d2 < 0 ) {
 600     return 1;
 601   }
 602   if ( a1 > 127 || a1 < 0 ||
 603        a2 > 127 || a2 < 0 ||
 604        a3 > 127 || a3 < 0 ) {
 605     /* Invalid value of yamaha address */
 606     return 1;
 607   }
 608
 609   rcp->result_smf[0] = 0xf0;   /* Exclusive status */
 610   rcp->result_smf[1] = 8;      /* Packet length */
 611   rcp->result_smf[2] = 0x43;   /* Vendor ID - YAMAHA */
 612   rcp->result_smf[3] = d1;     /* Device ID */
 613   rcp->result_smf[4] = d2;     /* Model ID */
 614   rcp->result_smf[5] = a1;
 615   rcp->result_smf[6] = a2;
 616   rcp->result_smf[7] = a3;
 617   rcp->result_smf[8] = v;
 618   rcp->result_smf[9] = 0xf7;
 619   rcp->result_smf[10] = SMF_TERM;
 620
 621   return 0;
 622 }
 623
 624 int rcp_yamaha_xg_ad(RCP_DATA *rcp, int track ){
 625
 626   int d1,d2;
 627   int a1,a2,a3;
 628   int v;
 629
 630   d1 = 0x10;
 631   d2 = 0x4c;
 632
 633   a1 = rcp->track[track].yamaha_base[1];
 634   a2 = rcp->track[track].yamaha_base[1];
 635   a3 = rcp->track[track].gate;
 636
 637   v   = rcp->track[track].vel;
 638
 639   if ( v > 127 || v < 0 ) {
 640     /* invalid value of yamaha device number */
 641     return 1;
 642   }
 643   if ( a1 > 127 || a1 < 0 ||
 644        a2 > 127 || a2 < 0 ||
 645        a3 > 127 || a3 < 0 ) {
 646     /* Invalid value of yamaha address */
 647     return 1;
 648   }
 649
 650   rcp->result_smf[0] = 0xf0;   /* Exclusive status */
 651   rcp->result_smf[1] = 8;      /* Packet length */
 652   rcp->result_smf[2] = 0x43;   /* Vendor ID - YAMAHA */
 653   rcp->result_smf[3] = d1;     /* Device ID */
 654   rcp->result_smf[4] = d2;     /* Model ID */
 655   rcp->result_smf[5] = a1;
 656   rcp->result_smf[6] = a2;
 657   rcp->result_smf[7] = a3;
 658   rcp->result_smf[8] = v;
 659   rcp->result_smf[9] = 0xf7;
 660   rcp->result_smf[10] = SMF_TERM;
 661
 662   return 0;
 663
 664 }
 665
 666 int rcp_roland_dev(RCP_DATA *rcp, int track ){
 667
 668   int v1, v2;
 669
 670   v1 = rcp->track[track].gate;
 671   v2 = rcp->track[track].vel;
 672   if ( v1 > 127 || v1 < 0 ) {
 673     /* invalid value of roland device number */
 674     return 1;
 675   }
 676   if ( v2 > 127 || v2 < 0 ) {
 677     /* invalid value of roland device number */
 678     return 1;
 679   }
 680
 681   rcp->roland_dev_id   = v1;
 682   rcp->roland_model_id = v2;
 683
 684   return 0;
 685 }
 686
 687 int rcp_roland_base(RCP_DATA *rcp, int track ){
 688
 689   int v1, v2;
 690
 691   v1 = rcp->track[track].gate;
 692   v2 = rcp->track[track].vel;
 693   if ( v1 > 127 || v1 < 0 ) {
 694     /* invalid value of roland base */
 695     return 1;
 696   }
 697   if ( v2 > 127 || v2 < 0 ) {
 698     /* invalid value of roland base */
 699     return 1;
 700   }
 701
 702   rcp->track[track].roland_base[0] = v1;
 703   rcp->track[track].roland_base[1] = v2;
 704
 705   return 0;
 706 }
 707
 708 int rcp_roland_para(RCP_DATA *rcp, int track ){
 709
 710   int d1,d2;
 711   int a1,a2,a3;
 712   int v;
 713
 714   d1 = rcp->roland_dev_id;
 715   d2 = rcp->roland_model_id;
 716
 717   a1 = rcp->track[track].roland_base[0];
 718   a2 = rcp->track[track].roland_base[1];
 719   a3 = rcp->track[track].gate;
 720
 721   v  = rcp->track[track].vel;
 722
 723   if ( v > 127 || v < 0 ) {
 724     /* Invalid value of roland data */
 725     return 1;
 726   }
 727   if ( d1 > 127 || d1 < 0 ||
 728        d2 > 127 || d2 < 0 ) {
 729     return 1;
 730   }
 731   if ( a1 > 127 || a1 < 0 ||
 732        a2 > 127 || a2 < 0 ||
 733        a3 > 127 || a3 < 0 ) {
 734     /* Invalid value of roland address */
 735     return 1;
 736   }
 737
 738   rcp->result_smf[0] = 0xf0;   /* Exclusive status */
 739   rcp->result_smf[1] = 10;     /* Packet length */
 740   rcp->result_smf[2] = 0x41;   /* Vendor ID - Roland */
 741   rcp->result_smf[3] = d1;     /* Device ID */
 742   rcp->result_smf[4] = d2;     /* Model ID */
 743   rcp->result_smf[5] = 0x12;   /* Roland Command - DT1 */
 744   rcp->result_smf[6] = a1;
 745   rcp->result_smf[7] = a2;
 746   rcp->result_smf[8] = a3;
 747   rcp->result_smf[9] = v;
 748   rcp->result_smf[10]= 0x80-((a1+a2+a3+v)&0x7f);
 749   rcp->result_smf[11]= 0xf7;
 750   rcp->result_smf[12]= SMF_TERM;
 751
 752   return 0;
 753 }
 754
 755 int rcp_key_change(RCP_DATA *rcp, int track ){
 756
 757   int sf,mi;
 758   int v, vv;
 759
 760   v = rcp->track[track].step;
 761   vv = v%0x10;
 762   sf = vv > 0x07 ? (0x100-vv)%0x100 : vv;
 763   mi = v  > 0x0f ? 1:0;
 764
 765   rcp->result_smf[0] = MIDI_META;
 766   rcp->result_smf[1] = META_KEYSIG;
 767   rcp->result_smf[2] = 0x02;
 768   rcp->result_smf[3] = sf;
 769   rcp->result_smf[4] = mi;
 770   rcp->result_smf[5] = SMF_TERM;
 771
 772   return 0;
 773 }
 774
 775 int rcp_comment_start(RCP_DATA *rcp, int track ){
 776
 777   int ptr;
 778   int length;
 779   int i,j;
 780   int *l;
 781   unsigned char *data = rcp->data;
 782
 783   length=2;
 784   ptr = rcp->track[track].current_ptr+4;
 785   while ( data[ptr+0] == RCP_2ND_EVENT ) {
 786     length+=2;
 787     ptr+=4;
 788     if ( ptr >= rcp->track[track].top + rcp->track[track].size )
 789       break;
 790   }
 791
 792   i=0;
 793   rcp->result_smf[i++] = MIDI_META;
 794   rcp->result_smf[i++] = META_TEXT;
 795
 796   l=smf_number_conversion((long)length);
 797   j=0;
 798   do {
 799     rcp->result_smf[i] = l[j];
 800     if ( i < RCP_MAX_RESULT_SMF_SIZE ) i++;
 801   }  while ( l[j++] >= 0x80 );
 802
 803   ptr = rcp->track[track].current_ptr;
 804   rcp->result_smf[i++] = data[ptr+2] == 0 ? 0x20 : data[ptr+2];
 805   rcp->result_smf[i++] = data[ptr+3] == 0 ? 0x20 : data[ptr+3];
 806   ptr+=4;
 807   while( data[ptr+0] == RCP_2ND_EVENT ) {
 808     if ( i >= RCP_MAX_RESULT_SMF_SIZE - 2 ) continue;
 809
 810     rcp->result_smf[i++] = data[ptr+2] == 0 ? 0x20 : data[ptr+2];
 811     rcp->result_smf[i++] = data[ptr+3] == 0 ? 0x20 : data[ptr+3];
 812     ptr+=4;
 813     if ( ptr >= rcp->track[track].top + rcp->track[track].size ) {
 814       /* Comment overflow */
 815       return 1;
 816     }
 817   }
 818
 819   rcp->result_smf[i] = SMF_TERM;
 820   rcp->track[track].current_ptr = ptr-4;
 821
 822   return 0;
 823 }
 824
 825 int rcp_loop_end(RCP_DATA *rcp, int track ){
 826
 827   LOOP_DATA *l;
 828   int c;
 829   int d = rcp->track[track].loop_depth;
 830   if ( d == 0 ) return -1;
 831
 832   l = &rcp->track[track].loop[d];
 833   c = l->loop_count;
 834   if ( c == -1 ) {
 835     c = rcp->track[track].step;
 836     if ( rcp->is_player == FLAG_FALSE ) {
 837       if ( c==0 || c==255 ) c=2;
 838
 839       /* loop_count =0 means infinite loops.
 840          loop_count = 255 also means pseudo infinite loops.
 841          We treat these infinite loops as two times loops.
 842          This conversion prevents the result of conversion from increasing
 843          the size, but the music may be curious...
 844          I'm planning to treats these with some fade-out features.
 845          */
 846     }
 847   }
 848   c--;
 849   if ( c != 0 ) {
 850     rcp->track[track].current_ptr = l->top_ptr;
 851     rcp->track[track].same_measure_flag = l->same_measure_flag;
 852     rcp->track[track].same_measure_ptr = l->same_measure_ptr;
 853     if ( c == -1 ) c=0; /* for infinite loop */
 854   }
 855   else
 856     d--;
 857
 858   l->loop_count = c;
 859   rcp->track[track].loop_depth = d;
 860
 861   return 0;
 862 }
 863
 864 int rcp_loop_start(RCP_DATA *rcp, int track ){
 865
 866   LOOP_DATA *l;
 867   int d = rcp->track[track].loop_depth;
 868   d++;
 869   if ( d >= RCP_MAX_LOOPS ) return -1;
 870
 871   l = &rcp->track[track].loop[d];
 872
 873   l->top_ptr = rcp->track[track].current_ptr;
 874   l->loop_count = -1;                        /* initial value */
 875   l->same_measure_flag = rcp->track[track].same_measure_flag;
 876   l->same_measure_ptr  = rcp->track[track].same_measure_ptr;
 877
 878   rcp->track[track].loop_depth = d;
 879
 880   return 0;
 881 }
 882
 883 int rcp_same_measure(RCP_DATA *rcp, int track ){
 884
 885   if (  rcp->track[track].same_measure_flag == FLAG_FALSE ) {
 886     /* enter the first SAME_MEASURE */
 887     int ptr,adr;
 888     rcp->track[track].same_measure_ptr = rcp->track[track].current_ptr;
 889     rcp->track[track].same_measure_flag = FLAG_TRUE;
 890
 891   resame:
 892     adr = rcp->track[track].current_ptr;
 893     ptr = (rcp->data[adr+2]&0xfc) + rcp->data[adr+3]*256 + rcp->track[track].top;
 894     if ( ptr != adr &&
 895          ptr < rcp->track[track].top + rcp->track[track].size ) {
 896       rcp->track[track].current_ptr = ptr;
 897       if ( rcp->data[ptr+0] == RCP_SAME_MEASURE ) { goto resame; }
 898       rcp->track[track].current_ptr-=4;
 899     }
 900   }
 901   else {             /* same as measure_end */
 902     rcp->track[track].same_measure_flag = FLAG_FALSE;
 903     rcp->track[track].current_ptr = rcp->track[track].same_measure_ptr;
 904   }
 905
 906   return 0;
 907 }
 908
 909 int rcp_measure_end(RCP_DATA *rcp, int track ){
 910
 911   if (  rcp->track[track].same_measure_flag == FLAG_TRUE ) {
 912     rcp->track[track].same_measure_flag = FLAG_FALSE;
 913     rcp->track[track].current_ptr = rcp->track[track].same_measure_ptr;
 914   }
 915
 916   return 0;
 917 }
 918
 919 int rcp_end_of_track(RCP_DATA *rcp, int track ){
 920
 921   rcp->result_smf[0] = MIDI_META;
 922   rcp->result_smf[1] = META_EOT;
 923   rcp->result_smf[2] = 0;
 924   rcp->result_smf[3] = SMF_TERM;
 925
 926   return 0;
 927 }
 928
 929 /* ------------------------------------------------------------------- */
 930 /*
 931   These following functions are not implemented.
 932   But I think these are tooooo obsolete so the sabotage will not cause
 933   any problems.
 934   */
 935
 936 int rcp_dx7_function(RCP_DATA *rcp, int track ){
 937   return -1;
 938 }
 939
 940 int rcp_dx_parameter(RCP_DATA *rcp, int track ){
 941   return -1;
 942 }
 943
 944 int rcp_dx_rerf(RCP_DATA *rcp, int track ){
 945   return -1;
 946 }
 947
 948 int rcp_tx_function(RCP_DATA *rcp, int track ){
 949   return -1;
 950 }
 951
 952 int rcp_fb01_parameter(RCP_DATA *rcp, int track ){
 953   return -1;
 954 }
 955
 956 int rcp_fb01_system(RCP_DATA *rcp, int track ){
 957   return -1;
 958 }
 959
 960 int rcp_tx81z_vced(RCP_DATA *rcp, int track ){
 961   return -1;
 962 }
 963
 964 int rcp_tx81z_aced(RCP_DATA *rcp, int track ){
 965   return -1;
 966 }
 967
 968 int rcp_tx81z_pced(RCP_DATA *rcp, int track ){
 969   return -1;
 970 }
 971
 972 int rcp_tx81z_system(RCP_DATA *rcp, int track ){
 973   return -1;
 974 }
 975
 976 int rcp_tx81z_effect(RCP_DATA *rcp, int track ){
 977   return -1;
 978 }
 979
 980 int rcp_dx7_2_remote_sw(RCP_DATA *rcp, int track ){
 981   return -1;
 982 }
 983
 984 int rcp_dx7_2_aced(RCP_DATA *rcp, int track ){
 985   return -1;
 986 }
 987
 988 int rcp_dx7_2_pced(RCP_DATA *rcp, int track ){
 989   return -1;
 990 }
 991
 992 int rcp_tx802_pced(RCP_DATA *rcp, int track ){
 993   return -1;
 994 }
 995
 996 int rcp_mks_7(RCP_DATA *rcp, int track ){
 997   return -1;
 998 }