rcptomid.cpp

   1 /*
   2   RCP converter engine
   3
   4   Copyright 1999 by Daisuke Nagano <breeze.nagano@nifty.ne.jp>
   5   Feb.05.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
  30 #ifdef HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif /* HAVE_CONFIG_H */
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36
  37 #ifdef STDC_HEADERS
  38 # include <string.h>
  39 #else
  40 # ifdef HAVE_STRCHR
  41 #  define strchr index
  42 #  define strrchr rindex
  43 # endif
  44 #endif
  45
  46 #include "sted.h"
  47 #include "rcp.h"
  48 #include "smf.h"
  49 #include "rcp_functions.h"
  50 #include "gettext_wrapper.h"
  51 #include "version.h"
  52
  53 /* ------------------------------------------------------------------- */
  54
  55 static unsigned char *rcptomid_name      = (uint8*)"rcptomid";
  56 static unsigned char *undefined_date     = (uint8*)"2000-01-01";
  57 static unsigned char *undefined_filename = (uint8*)"(NO NAME)";
  58
  59 /* ------------------------------------------------------------------- */
  60
  61 #ifdef RCP_DEBUG
  62 # define RCPMSG(x,y) fprintf(stderr,x,y)
  63 #else
  64 # define RCPMSG(x,y)
  65 #endif
  66
  67
  68 typedef struct _TEMPO_EVENT_SEQUENCE {
  69
  70   int absolute_step;
  71   int t1;
  72   int t2;
  73   int t3;
  74
  75   struct _TEMPO_EVENT_SEQUENCE *next;
  76
  77 } TEMPO_EVENT_SEQUENCE;
  78
  79 /* ------------------------------------------------------------------- */
  80
  81 static TEMPO_EVENT_SEQUENCE *TES_top = (TEMPO_EVENT_SEQUENCE *)NULL;
  82
  83 /* ------------------------------------------------------------------- */
  84
  85 /* Converter engine */
  86
  87 unsigned char *rcptomid( RCP_DATA *rcp ) {
  88
  89   unsigned char *smf;
  90   int track;
  91
  92   int gate_min;
  93   int n,nt;
  94   int s;
  95
  96   if ( rcptomid_init_track_buffer( rcp ) != 0 ) return NULL;
  97   if ( rcptomid_read_rcp_header( rcp )   != 0 ) return NULL;
  98
  99   for ( track = 0 ; track < rcp->tracks ; track++ ) {
 100     rcp->roland_dev_id   = 0x10;
 101     rcp->roland_model_id = 0x16;
 102     rcp->yamaha_dev_id   = 0x10;
 103     rcp->yamaha_model_id = 0x16;
 104
 105     rcp->step            = 0;
 106
 107     init_track_header( rcp, track );
 108     rcp->result_smf[0]   = SMF_TERM;
 109
 110     while ( rcp->track[track].finished == FLAG_FALSE ) {
 111
 112       if ( rcp->track[track].all_notes_expired == FLAG_TRUE )
 113         goto rcptomid_expire_event;
 114
 115       /* checks for each notes' gate time is expired */
 116       gate_min = rcp->track[track].step;
 117       nt = -1;
 118       for ( n = rcp->track[track].notes_min ;
 119             n <= rcp->track[track].notes_max ; n++ ) {
 120         if ( rcp->track[track].notes[n] == 0 ) continue;
 121         if ( rcp->track[track].notes[n] <= gate_min ) {
 122           gate_min = rcp->track[track].notes[n];
 123           nt = n;
 124         }
 125       }
 126       if ( nt < 0 ) goto rcptomid_expire_event;
 127
 128       /* note-off */
 129       rcp->step += gate_min;
 130       rcp->track[track].delta_step += gate_min;
 131       rcp->track[track].total_step += gate_min;
 132       rcp->track[track].step -= gate_min;
 133       for ( n = rcp->track[track].notes_min ;
 134             n <=rcp->track[track].notes_max ; n++ ) {
 135         if ( rcp->track[track].notes[n] == gate_min ) {
 136           rcp_note_off( rcp, track, n );
 137           flush_event( rcp, track );
 138         }
 139         rcp->track[track].notes[n] -= gate_min;
 140         if ( rcp->track[track].notes[n] < 0 ) {
 141           rcp->track[track].notes[n] = 0;
 142         }
 143       }
 144       continue;
 145
 146       /* checks for step time is expired */
 147
 148     rcptomid_expire_event:
 149
 150       s = rcp->track[track].step;
 151       rcp->step += s;
 152       rcp->track[track].delta_step += s;
 153       rcp->track[track].total_step += s;
 154       rcp->track[track].step = 0;
 155       for ( n = rcp->track[track].notes_min ;
 156             n <=rcp->track[track].notes_max ; n++ ) {
 157         rcp->track[track].notes[n] -= s;
 158         if ( rcp->track[track].notes[n] < 0 ) {
 159           rcp->track[track].notes[n] = 0;
 160         }
 161       }
 162       while ( rcp->track[track].step == 0 ) {
 163         rcptomid_set_new_event( rcp, track );
 164         if ( rcp->track[track].finished == FLAG_FALSE )
 165           flush_event( rcp, track );
 166         else break;
 167       }
 168     }
 169
 170     while ( 1 ) {
 171       gate_min = 65536*2; /* large enough */
 172       for ( n=0 ; n<RCP_MAX_NOTES ; n++ ) {
 173         if ( rcp->track[track].notes[n] <= 0 ) continue;
 174         if ( rcp->track[track].notes[n] <= gate_min ) {
 175           gate_min = rcp->track[track].notes[n];
 176         }
 177       }
 178       if ( gate_min == 65536*2 ) break;
 179       for ( n=0 ; n<RCP_MAX_NOTES ; n++ ) {
 180         if ( rcp->track[track].notes[n] == gate_min ) {
 181           rcp_note_off( rcp, track, n );
 182           flush_event( rcp, track );
 183         }
 184         rcp->track[track].notes[n]-=gate_min;
 185         if ( rcp->track[track].notes[n] < 0 )
 186           rcp->track[track].notes[n] = 0;
 187       }
 188     }
 189
 190     rcp->result_smf[0] = MIDI_META;
 191     rcp->result_smf[1] = META_EOT;
 192     rcp->result_smf[2] = 0;
 193     rcp->result_smf[3] = SMF_TERM;
 194     flush_event( rcp, track );
 195   }
 196
 197   /* set up first / tempo track */
 198   set_tempo_track( rcp );
 199
 200   /* create SMF data */
 201   smf = set_smf_data( rcp );
 202
 203   return smf;
 204 }
 205
 206 /* ------------------------------------------------------------------- */
 207
 208 int rcptomid_init_track_buffer( RCP_DATA *rcp ) {
 209
 210   int track,n;
 211
 212   rcp->roland_dev_id   = 0x10;
 213   rcp->roland_model_id = 0x16;
 214   rcp->yamaha_dev_id   = 0x10;
 215   rcp->yamaha_model_id = 0x16;
 216
 217   rcp->step            = -1;
 218   rcp->result_smf[0]   = SMF_TERM;
 219
 220   for ( track=0 ; track<RCP_MAX_TRACKS ; track++ ) {
 221     rcp->track[track].enabled    = FLAG_FALSE;
 222     rcp->track[track].finished   = FLAG_FALSE;
 223
 224     rcp->track[track].gate       = 0;
 225     rcp->track[track].step       = 1;
 226     rcp->track[track].delta_step = -1;   /* initial value should be -1 */
 227     rcp->track[track].total_step = -1;
 228
 229     rcp->track[track].yamaha_base[0]  = -1; /* not specified */
 230     rcp->track[track].roland_base[0]  = -1; /* not specified */
 231
 232     rcp->track[track].loop_depth      = 0;
 233     rcp->track[track].same_measure_flag = FLAG_FALSE;
 234
 235     rcp->track[track].current_ptr     = 0;
 236
 237     for ( n=0 ; n<RCP_MAX_NOTES ; n++ )
 238       rcp->track[track].notes[n] = 0;
 239     rcp->track[track].notes_min = 127;
 240     rcp->track[track].notes_max = 0;
 241     rcp->track[track].all_notes_expired = FLAG_TRUE;
 242
 243     rcp->track[track].smf =
 244       (unsigned char *)malloc(sizeof(unsigned char)*RCP_DEFAULT_SMF_SIZE);
 245     if ( rcp->track[track].smf == NULL ) {
 246       /* Memory exhaust */
 247       return 1;
 248     }
 249     rcp->track[track].smf_ptr   = 0;
 250   }
 251
 252   TES_top = (TEMPO_EVENT_SEQUENCE *)malloc(sizeof(TEMPO_EVENT_SEQUENCE));
 253   if ( TES_top == (TEMPO_EVENT_SEQUENCE *)NULL ) {
 254     /* Memory exhaust */
 255     return 1;
 256   }
 257   TES_top->absolute_step = 0;    /* Initial value */
 258   TES_top->next = NULL;
 259
 260   rcp->smf_tempo_track = (unsigned char *)malloc(sizeof(unsigned char)*RCP_DEFAULT_SMF_SIZE);
 261   if ( rcp->smf_tempo_track == (unsigned char *)NULL ) {
 262     /* Memory exhaust */
 263     return 1;
 264   }
 265   rcp->smf_tempo_track_ptr = 0;
 266
 267   return 0;
 268 }
 269
 270 int rcptomid_read_rcp_header( RCP_DATA *rcp ) {
 271
 272   int i,j;
 273   int t;
 274   int base,size,max_st;
 275   unsigned char *ptr;
 276
 277   ptr = rcp->data;
 278
 279   /* check 1st header */
 280
 281   if ( strncmp( (char*)ptr, RCP_HEADER_STRING, 28 ) ==0 ) {
 282     rcp->rcp = FLAG_TRUE;
 283     rcp->g36 = FLAG_FALSE;
 284   } else if ( strncmp( (char*)ptr, STEDDATA_HEADER_STRING, 8 ) ==0 &&
 285               strncmp( (char*)ptr+12, (char*)STEDDATA_HEADER_STRING+12, 16 ) ==0 ) {
 286     rcp->steddata = FLAG_TRUE;
 287     rcp->rcp = FLAG_TRUE;
 288     rcp->g36 = FLAG_FALSE;
 289   } else {
 290     return -1;
 291   }
 292
 293   /* title, memo */
 294
 295   for ( i=0 ; i<65 ; i++ )
 296     rcp->title[i] = '\0';
 297   for ( i=0 ; i<337 ; i++ )
 298     rcp->memo[i] = '\0';
 299   memcpy( rcp->title, ptr+0x0020, 64  );  /* It should be SJIS */
 300   memcpy( rcp->memo,  ptr+0x0060, 336 );  /* It should be SJIS */
 301
 302   /* timebase, tempo, etc */
 303
 304   rcp->timebase  = ptr[0x01c0] + ptr[0x01e7]*256;
 305   if ( rcp->timebase>480 || rcp->timebase<0 ) return 1;
 306   rcp->tempo     = ptr[0x01c1];
 307   rcp->realtempo = ptr[0x01c1];
 308   rcp->beat_h    = ptr[0x01c2];
 309   rcp->beat_l    = ptr[0x01c3];
 310   rcp->key       = ptr[0x01c4];
 311   rcp->play_bias = ptr[0x01c5];
 312   rcp->rtm_delta = rcp->timebase / 24;
 313
 314   rcp->tracks   = ptr[0x01e6];
 315   if ( rcp->tracks == 0 ) rcp->tracks = 18;
 316   /*if ( rcp->tracks !=18 && rcp->tracks !=36 ) return 1;*/
 317
 318   t = 1000 * 1000 * 60 / rcp->tempo;
 319   TES_top->t1 = (int)((t>>16)&0xff);
 320   TES_top->t2 = (int)((t>> 8)&0xff);
 321   TES_top->t3 = (int)(t&0xff);
 322
 323   RCPMSG("TITLE     : %s\n", rcp->title);
 324   RCPMSG("MEMO      : %s\n", rcp->memo);
 325   RCPMSG("TIMEBASE  : %d\n", rcp->timebase);
 326   RCPMSG("TEMPO     : %d\n", rcp->tempo);
 327   RCPMSG("BEAT_H    : %d\n", rcp->beat_h);
 328   RCPMSG("BEAT_L    : %d\n", rcp->beat_l);
 329   RCPMSG("KEY       : %d\n", rcp->key);
 330   RCPMSG("PLAY BIAS : %d\n", rcp->play_bias);
 331   RCPMSG("TRACKS    : %d\n\n", rcp->tracks);
 332
 333   /* user exclusive definition */
 334
 335   for ( i=0 ; i<RCP_MAX_USER_EXCLUSIVE ; i++ ) {
 336     for ( j=0 ; j<RCP_USER_EXCLUSIVE_SIZE ; j++ ) {
 337       rcp->user_exclusive[i][j] = ptr[0x0406 + i*48 + 24+j];
 338     }
 339   }
 340
 341   /* track headers */
 342
 343   base = 0x0586;
 344   size = 0;
 345   max_st = 0;
 346   for ( t=0 ; t<rcp->tracks ; t++ ) {
 347     int ch;
 348
 349     base = base + size;
 350     rcp->track[t].top = base;
 351
 352     size = ptr[base+0] + ptr[base+1]*256;
 353     rcp->track[t].size = size;
 354
 355     ch = ptr[base+4];
 356     if ( ch == 0xff ) {
 357       rcp->track[t].enabled = FLAG_FALSE;
 358       rcp->track[t].midi_ch = 0;
 359       rcp->track[t].port    = 0;
 360     }
 361     else {
 362       rcp->track[t].enabled = FLAG_TRUE;
 363       rcp->track[t].midi_ch = ch&0x0f;
 364       if ( rcp->steddata ) {
 365         rcp->track[t].port    = ch>>4&0x0f;
 366       } else {
 367         rcp->track[t].port  = ch>0x10 ? 1:0;
 368       }
 369     }
 370
 371     if ( ptr[base+5] >= 0x80 )
 372       rcp->track[t].key     = 0x80;
 373     else {
 374       if ( ptr[base+5] > 63 )
 375         rcp->track[t].key   = ptr[base+5]-128;
 376       else
 377         rcp->track[t].key   = ptr[base+5];
 378     }
 379     rcp->track[t].st        = ptr[base+6];
 380     rcp->track[t].mode      = ptr[base+7];
 381
 382     i = (rcp->track[t].st > 0x7f) ? rcp->track[t].st-0x100:0;
 383     if ( max_st > i ) max_st = i;
 384
 385     if ( rcp->track[t].mode == 1 )
 386       rcp->track[t].enabled = FLAG_FALSE;
 387
 388     for ( j=0 ; j<RCP_MAX_COMMENT_SIZE ; j++ ) {
 389       rcp->track[t].comment[j] = ptr[base+8+j];   /* It should be SJIS */
 390     }
 391
 392     rcp->track[t].current_ptr = base+8+RCP_MAX_COMMENT_SIZE;
 393
 394     RCPMSG("Track   : %d\n", t);
 395     RCPMSG("Base    : %d\n", rcp->track[t].top);
 396     RCPMSG("Size    : %d\n", rcp->track[t].size);
 397     RCPMSG("MIDI CH : %d\n", rcp->track[t].midi_ch);
 398     RCPMSG("Key     : %d\n", rcp->track[t].key);
 399     RCPMSG("ST      : %d\n", rcp->track[t].st);
 400     RCPMSG("Mode    : %d\n", rcp->track[t].mode);
 401     RCPMSG("Comment : %s\n\n", rcp->track[t].comment);
 402   }
 403
 404   for ( t=0 ; t<rcp->tracks ; t++ ) {
 405     i = rcp->track[t].st > 0x7f ? rcp->track[t].st - 0x100 : rcp->track[t].st;
 406     rcp->track[t].step = 1+i-max_st;
 407   }
 408
 409   return 0;
 410 }
 411
 412 int init_track_header( RCP_DATA *rcp, int track ) {
 413
 414   int i,j;
 415
 416   if ( rcp->track[track].enabled == FLAG_FALSE ) return 0;
 417
 418   /* track memo */
 419   i=0;
 420   rcp->result_smf[i++] = MIDI_META;
 421   rcp->result_smf[i++] = META_SEQNAME;
 422   rcp->result_smf[i++] = RCP_MAX_COMMENT_SIZE;
 423   for ( j=0 ; j<RCP_MAX_COMMENT_SIZE ; j++ ) {
 424     unsigned char c = rcp->track[track].comment[j];
 425     if ( c == 0 ) c = 0x20;
 426     rcp->result_smf[i++] = c;
 427   }
 428
 429 #ifdef ENABLE_PORT_CHANGE
 430   /* MIDI channel */
 431   rcp->result_smf[i++] = 0; /* delta time = 0 */
 432   rcp->result_smf[i++] = MIDI_META;
 433   rcp->result_smf[i++] = META_PORT;
 434   rcp->result_smf[i++] = 1;  /* one byte follow */
 435   rcp->result_smf[i++] = rcp->track[track].port;
 436 #endif /* ENABLE_PORT_CHANGE */
 437
 438   rcp->result_smf[i++] = SMF_TERM;
 439   rcp->track[track].delta_step = 0;
 440   flush_event( rcp, track );
 441
 442   rcp->step = -1;
 443   rcp->track[track].delta_step = -1;
 444
 445   return 0;
 446 }
 447
 448 int rcptomid_set_new_event( RCP_DATA *rcp, int t ) {
 449
 450   int ptr;
 451   unsigned char *data;
 452   int ret;
 453
 454   ret = 0;
 455   data = rcp->data;
 456   ptr  = rcp->track[t].current_ptr;
 457
 458   if ( ptr > rcp->track[t].top + rcp->track[t].size ) {
 459     rcp->track[t].finished = FLAG_TRUE;
 460     return -1;
 461   }
 462
 463   rcp->track[t].event = data[ptr+0];
 464   rcp->track[t].step  = data[ptr+1];
 465   rcp->track[t].gate  = data[ptr+2];
 466   rcp->track[t].vel   = data[ptr+3];
 467
 468   /*
 469   fprintf(stderr,"%d : %02x %d %d %d\n", t,
 470           rcp->track[t].event,
 471           rcp->track[t].step,
 472           rcp->track[t].gate,
 473           rcp->track[t].vel );
 474           */
 475
 476   if ( rcp->track[t].event < 0x80 ) {     /* note event */
 477     rcp_note_on( rcp, t );
 478   } else {
 479     switch ( rcp->track[t].event ) {
 480
 481     case RCP_USER_EXCLUSIVE_1:
 482     case RCP_USER_EXCLUSIVE_2:
 483     case RCP_USER_EXCLUSIVE_3:
 484     case RCP_USER_EXCLUSIVE_4:
 485     case RCP_USER_EXCLUSIVE_5:
 486     case RCP_USER_EXCLUSIVE_6:
 487     case RCP_USER_EXCLUSIVE_7:
 488     case RCP_USER_EXCLUSIVE_8:
 489       rcp_user_exclusive( rcp, t );
 490       break;
 491
 492     case RCP_CH_EXCLUSIVE:
 493       rcp_ch_exclusive( rcp, t );
 494       break;
 495
 496     case RCP_EXEC_EXTERN_PROG:
 497       rcp_exec_extern_prog( rcp, t );
 498       ret = 1;
 499       break;
 500
 501     case RCP_BANK_AND_PROG:
 502       rcp_bank_and_prog( rcp, t );
 503       break;
 504
 505     case RCP_KEY_SCAN:
 506       rcp_key_scan( rcp, t );
 507       break;
 508
 509     case RCP_MIDI_CH_CHANGE:
 510       rcp_midi_ch_change( rcp, t );
 511       break;
 512
 513     case RCP_TEMPO_CHANGE:
 514       rcp_tempo_change( rcp, t );
 515       break;
 516
 517     case RCP_AFTER_TOUCH:
 518       rcp_after_touch( rcp, t );
 519       break;
 520
 521     case RCP_CONTROL_CHANGE:
 522       rcp_control_change( rcp, t );
 523       break;
 524
 525     case RCP_PROGRAM_CHANGE:
 526       rcp_program_change( rcp, t );
 527       break;
 528
 529     case RCP_AFTER_TOUCH_POLY:
 530       rcp_after_touch_poly( rcp, t );
 531       break;
 532
 533     case RCP_PITCH_BEND:
 534       rcp_pitch_bend( rcp, t );
 535       break;
 536
 537     case RCP_YAMAHA_BASE:
 538       rcp_yamaha_base( rcp, t );
 539       break;
 540
 541     case RCP_YAMAHA_DEV_NUM:
 542       rcp_yamaha_dev_name( rcp, t );
 543       break;
 544
 545     case RCP_YAMAHA_ADDR:
 546       rcp_yamaha_addr( rcp, t );
 547       break;
 548
 549     case RCP_YAMAHA_XG_AD:
 550       rcp_yamaha_xg_ad( rcp, t );
 551       break;
 552
 553     case RCP_ROLAND_BASE:
 554       rcp_roland_base( rcp, t );
 555       break;
 556
 557     case RCP_ROLAND_PARA:
 558       rcp_roland_para( rcp, t );
 559       break;
 560
 561     case RCP_ROLAND_DEV:
 562       rcp_roland_dev( rcp, t );
 563       break;
 564
 565     case RCP_KEY_CHANGE:
 566       rcp_key_change( rcp, t );
 567       ret = 1;
 568       break;
 569
 570     case RCP_COMMENT_START:
 571       rcp_comment_start( rcp, t );
 572       ret = 1;
 573       break;
 574
 575     case RCP_LOOP_END:
 576       rcp_loop_end( rcp, t );
 577       ret = 1;
 578       break;
 579
 580     case RCP_LOOP_START:
 581       rcp_loop_start( rcp, t );
 582       ret = 1;
 583       break;
 584
 585     case RCP_SAME_MEASURE:
 586       rcp_same_measure( rcp, t );
 587       ret = 1;
 588       break;
 589
 590     case RCP_MEASURE_END:
 591       rcp_measure_end( rcp, t );
 592       ret = 1;
 593       break;
 594
 595     case RCP_END_OF_TRACK:
 596       rcp_end_of_track( rcp, t );
 597       ret=-1;
 598       break;
 599
 600     case RCP_DX7_FUNCTION:
 601       rcp_dx7_function( rcp, t );
 602       break;
 603
 604     case RCP_DX_PARAMETER:
 605       rcp_dx_parameter( rcp, t );
 606       break;
 607
 608     case RCP_DX_RERF:
 609       rcp_dx_rerf( rcp, t );
 610       break;
 611
 612     case RCP_TX_FUNCTION:
 613       rcp_tx_function( rcp, t );
 614       break;
 615
 616     case RCP_FB01_PARAMETER:
 617       rcp_fb01_parameter( rcp, t );
 618       break;
 619
 620     case RCP_FB01_SYSTEM:
 621       rcp_fb01_system( rcp, t );
 622       break;
 623
 624     case RCP_TX81Z_VCED:
 625       rcp_tx81z_vced( rcp, t );
 626       break;
 627
 628     case RCP_TX81Z_ACED:
 629       rcp_tx81z_aced( rcp, t );
 630       break;
 631
 632     case RCP_TX81Z_PCED:
 633       rcp_tx81z_pced( rcp, t );
 634       break;
 635
 636     case RCP_TX81Z_SYSTEM:
 637       rcp_tx81z_system( rcp, t );
 638       break;
 639
 640     case RCP_TX81Z_EFFECT:
 641       rcp_tx81z_effect( rcp, t );
 642       break;
 643
 644     case RCP_DX7_2_REMOTE_SW:
 645       rcp_dx7_2_remote_sw( rcp, t );
 646       break;
 647
 648     case RCP_DX7_2_ACED:
 649       rcp_dx7_2_aced( rcp, t );
 650       break;
 651
 652     case RCP_DX7_2_PCED:
 653       rcp_dx7_2_pced( rcp, t );
 654       break;
 655
 656     case RCP_TX802_PCED:
 657       rcp_tx802_pced( rcp, t );
 658       break;
 659
 660     case RCP_MKS_7:
 661       rcp_mks_7( rcp, t );
 662       break;
 663
 664     case RCP_2ND_EVENT:
 665       ret = 1;
 666       break;
 667
 668     default:
 669       ret=-1;
 670       break;
 671     }
 672   }
 673
 674   if ( ret == 1 )
 675     rcp->track[t].step = 0;
 676
 677   ptr=rcp->track[t].current_ptr;
 678   ptr+=4;
 679   if ( ptr >= rcp->track[t].top + rcp->track[t].size ||
 680        ret == -1 ) {
 681     rcp->track[t].finished = FLAG_TRUE;
 682     rcp->track[t].step=-1;
 683     ptr = -1;
 684   }
 685   rcp->track[t].current_ptr = ptr;
 686
 687   return  ret;
 688 }
 689
 690 int flush_event( RCP_DATA *rcp, int track ) {
 691
 692   int i,*len;
 693   int ptr;
 694
 695   if ( rcp->result_smf[0] == SMF_TERM ) return 0;
 696
 697   /* is the event set-tempo ? */
 698   if ( rcp->result_smf[0] == MIDI_META &&
 699        rcp->result_smf[1] == META_TEMPO ) {
 700
 701     insert_tempo_event( rcp );
 702     goto flush_event_end;
 703   }
 704
 705   /* is the track disabled ? */
 706   if ( rcp->track[track].enabled == FLAG_FALSE &&
 707        rcp->result_smf[0] != MIDI_NOTEOFF ) {
 708     goto flush_event_end;
 709   }
 710
 711   /* flushing smf data */
 712   i=0;
 713   ptr = rcp->track[track].smf_ptr;
 714
 715   if ( rcp->track[track].delta_step < 0 ) {
 716     fprintf(stderr,"%d\n",(int)rcp->track[track].delta_step);
 717   }
 718
 719   len = smf_number_conversion( rcp->track[track].delta_step );
 720   do {
 721     rcp->track[track].smf[ptr++] = len[i];
 722     if ( (ptr % RCP_DEFAULT_SMF_SIZE) == 0 ) {
 723       int size;
 724       size = (1+ptr/RCP_DEFAULT_SMF_SIZE) * RCP_DEFAULT_SMF_SIZE;
 725       if ( (rcp->track[track].smf = (uint8*)realloc( rcp->track[track].smf,
 726                     sizeof(unsigned char)*size )) == (unsigned char *)NULL ) {
 727         /* Memory exhaust */
 728         return 1;
 729       }
 730     }
 731   } while ( len[i++] >= 0x80 );
 732
 733   i=0;
 734   while ( rcp->result_smf[i] != SMF_TERM ) {
 735     rcp->track[track].smf[ptr++] = rcp->result_smf[i++];
 736
 737     if ( (ptr % RCP_DEFAULT_SMF_SIZE) == 0 ) {
 738       int size;
 739       size = (1+ptr/RCP_DEFAULT_SMF_SIZE) * RCP_DEFAULT_SMF_SIZE;
 740       if ( (rcp->track[track].smf = (uint8*)realloc( rcp->track[track].smf,
 741                     sizeof(unsigned char)*size )) == (unsigned char *)NULL ) {
 742         /* Memory exhaust */
 743         return 1;
 744       }
 745     }
 746   }
 747   rcp->track[track].smf_ptr = ptr;
 748   rcp->track[track].delta_step = 0;
 749
 750 flush_event_end:
 751   rcp->result_smf[0] = SMF_TERM;
 752
 753   return 0;
 754 }
 755
 756 int insert_tempo_event( RCP_DATA *rcp ) {
 757
 758   TEMPO_EVENT_SEQUENCE *t, *t_last, *t_new;
 759
 760   t_new = (TEMPO_EVENT_SEQUENCE *)malloc(sizeof(TEMPO_EVENT_SEQUENCE));
 761   if ( t_new == (TEMPO_EVENT_SEQUENCE *)NULL ) {
 762     /* Memory exhaust */
 763     return 1;
 764   }
 765   t_new->absolute_step = rcp->step;
 766   t_new->t1            = rcp->result_smf[3];
 767   t_new->t2            = rcp->result_smf[4];
 768   t_new->t3            = rcp->result_smf[5];
 769
 770   t = TES_top;
 771   t_last = TES_top;
 772   while ( t != (TEMPO_EVENT_SEQUENCE *)NULL ) {
 773     if ( t->absolute_step > t_new->absolute_step ) break;
 774
 775     t_last = t;
 776     t = t->next;
 777   }
 778   t_last->next = t_new;
 779   t_new->next  = t;
 780
 781   return 0;
 782 }
 783
 784 int set_tempo_track ( RCP_DATA *rcp ) {
 785
 786   TEMPO_EVENT_SEQUENCE *t = TES_top, *tn;
 787   int p;
 788   int dt,*d;
 789   int i,j,k;
 790   unsigned char *data;
 791   unsigned char buf[1024];
 792
 793   p = rcp->smf_tempo_track_ptr;
 794   data = rcp->smf_tempo_track;
 795
 796   /* Track header */
 797   /* Title */
 798
 799   data[p++] = 0;
 800   data[p++] = MIDI_META;
 801   data[p++] = META_SEQNAME;
 802   for ( i=0 ; i<64 ; i++ ) {
 803     unsigned char c = rcp->title[i];
 804     if ( c == 0 ) break;
 805   }
 806   data[p++] = i;
 807   for ( j=0 ; j<i ; j++ ) {
 808     data[p++] = rcp->title[j];
 809   }
 810
 811   /* Copyright notice */
 812   if ( rcp->copyright != NULL ) {
 813     data[p++] = 0;
 814     data[p++] = MIDI_META;
 815     data[p++] = META_COPYRIGHT;
 816     i=0;
 817     while ( rcp->copyright[i++] != 0 );
 818     data[p++] = i;
 819     for ( j=0 ; j<i ; j++ ) {
 820       data[p++] = rcp->copyright[j];
 821     }
 822   }
 823
 824   /* converter notice */
 825   if ( rcp->enable_converter_notice == FLAG_TRUE ) {
 826     int *len;
 827
 828     sprintf( (char*)buf,"\nThis file was converted by %s version %s (%s - %s).\nOriginal RCP file is \"%s\" (%s, %d bytes).",
 829              (rcp->command_name!=NULL)?rcp->command_name:rcptomid_name,
 830              VERSION_ID, VERSION_TEXT1, VERSION_TEXT2,
 831              (rcp->file_name!=NULL)?rcp->file_name:undefined_filename,
 832              (rcp->date!=NULL)?rcp->date:undefined_date,
 833              rcp->length );
 834
 835     i=0;
 836     while ( buf[i]!=0 ) i++;
 837
 838     data[p++] = 0; /* delta time = 0 */
 839     data[p++] = MIDI_META;
 840     data[p++] = META_TEXT;
 841
 842     len = smf_number_conversion( i );
 843     j=0;
 844     do {
 845       data[p++] = len[j];
 846     } while ( len[j++] >= 0x80 );
 847
 848     for ( j=0 ; j<i ; j++ ) {
 849       data[p++] = buf[j];
 850     }
 851   }
 852
 853   /* key */
 854
 855   j = rcp->key > 0x0f ? 1:0;
 856   i = rcp->key%0x10;
 857   if ( i > 0x07 ) i = (0x100-i)%0x100;
 858
 859   data[p++] = 0;
 860   data[p++] = MIDI_META;
 861   data[p++] = META_KEYSIG;
 862   data[p++] = 0x02;
 863   data[p++] = i;
 864   data[p++] = j;
 865
 866   /* beat */
 867
 868 #if 0
 869   data[p++] = 0;
 870   data[p++] = MIDI_META;
 871   data[p++] = META_TIMESIG;
 872   data[p++] = 0x04;
 873   data[p++] = 0;
 874   data[p++] = 0;
 875   data[p++] = 0;
 876   data[p++] = 0;
 877 #endif
 878
 879   /* Tempo */
 880
 881   dt = t->absolute_step;
 882   while ( t != NULL ) {
 883     k = p / RCP_DEFAULT_SMF_SIZE;
 884
 885     d = smf_number_conversion((long)dt);
 886     i=0;
 887     do {
 888       data[p++] = d[i];
 889     } while ( d[i++] >= 0x80 );
 890
 891     data[p++] = MIDI_META;
 892     data[p++] = META_TEMPO;
 893     data[p++] = 3;
 894     data[p++] = t->t1;
 895     data[p++] = t->t2;
 896     data[p++] = t->t3;
 897     if ( p > RCP_DEFAULT_SMF_SIZE*(k+1) ) {
 898       int size;
 899       size = (1+p/RCP_DEFAULT_SMF_SIZE) * RCP_DEFAULT_SMF_SIZE;
 900       if ( (rcp->smf_tempo_track = (uint8*)realloc( rcp->smf_tempo_track,
 901                     sizeof(unsigned char)*size )) == (unsigned char *)NULL ) {
 902         /* Memory exhaust */
 903         return 1;
 904       }
 905     }
 906
 907     if ( t->next != NULL )
 908       dt = t->next->absolute_step - t->absolute_step;
 909     t = t->next;
 910   }
 911
 912   data[p++] = 0;
 913   data[p++] = MIDI_META;
 914   data[p++] = META_EOT;
 915   data[p++] = 0;
 916
 917   rcp->smf_tempo_track_ptr = p;
 918
 919   t = TES_top;
 920   while ( t != NULL ) {
 921     tn = t;
 922     t = t->next;
 923     free(tn);
 924   }
 925
 926   return 0;
 927 }
 928
 929 unsigned char *set_smf_data( RCP_DATA *rcp ) {
 930
 931   long smf_size;
 932   unsigned char *smf_data;
 933   int t,tr;
 934   int ptr;
 935   int i;
 936
 937   /* Allocate memory for SMF data */
 938
 939   smf_size = SMF_MTHD_HEADER_SIZE +
 940     4+rcp->smf_tempo_track_ptr;
 941   tr=1;
 942   for (t=0 ; t<rcp->tracks ; t++ ) {
 943     if ( rcp->track[t].enabled == FLAG_TRUE ) {
 944       smf_size += 4+rcp->track[t].smf_ptr + 256;
 945       tr++;
 946     }
 947   }
 948   if ( smf_size > 0xffffffffL ) return NULL;
 949   smf_data = (unsigned char *)malloc(sizeof(unsigned char *) * smf_size);
 950   if ( smf_data == (unsigned char *)NULL )
 951     return NULL;
 952
 953   /* Set Header Chunk */
 954
 955   smf_data[0] = 'M';  /* Chunk type */
 956   smf_data[1] = 'T';
 957   smf_data[2] = 'h';
 958   smf_data[3] = 'd';
 959
 960   smf_data[4] = 0;
 961   smf_data[5] = 0;
 962   smf_data[6] = 0;
 963   smf_data[7] = 6;
 964
 965   smf_data[8] = 0;    /* Data format ( format 1 ) */
 966   smf_data[9] = 1;
 967
 968   smf_data[10] = tr / 256;
 969   smf_data[11] = tr % 256;
 970
 971   smf_data[12] = rcp->timebase / 256;
 972   smf_data[13] = rcp->timebase % 256;
 973
 974   /* Set first Track Chunk ( tempo track ) */
 975
 976   ptr = 14;
 977   smf_data[ptr++] = 'M';
 978   smf_data[ptr++] = 'T';
 979   smf_data[ptr++] = 'r';
 980   smf_data[ptr++] = 'k';
 981
 982   smf_data[ptr++] = (rcp->smf_tempo_track_ptr>>24)&0xff;
 983   smf_data[ptr++] = (rcp->smf_tempo_track_ptr>>16)&0xff;
 984   smf_data[ptr++] = (rcp->smf_tempo_track_ptr>>8 )&0xff;
 985   smf_data[ptr++] = (rcp->smf_tempo_track_ptr    )&0xff;
 986
 987   for ( i=0 ; i<rcp->smf_tempo_track_ptr ; i++ ) {
 988     smf_data[ptr++] = rcp->smf_tempo_track[i];
 989   }
 990
 991   /* Set all other Track Chunk ( Music track ) */
 992
 993   for ( t=0 ; t<rcp->tracks ; t++ ) {
 994     if ( rcp->track[t].enabled == FLAG_FALSE ) continue;
 995
 996     smf_data[ptr++] = 'M';
 997     smf_data[ptr++] = 'T';
 998     smf_data[ptr++] = 'r';
 999     smf_data[ptr++] = 'k';
1000
1001     smf_data[ptr++] = (rcp->track[t].smf_ptr>>24)&0xff;
1002     smf_data[ptr++] = (rcp->track[t].smf_ptr>>16)&0xff;
1003     smf_data[ptr++] = (rcp->track[t].smf_ptr>>8 )&0xff;
1004     smf_data[ptr++] = (rcp->track[t].smf_ptr    )&0xff;
1005
1006     for ( i=0 ; i<rcp->track[t].smf_ptr ; i++ ) {
1007       smf_data[ptr++] = rcp->track[t].smf[i];
1008     }
1009   }
1010
1011   /* free all smf data */
1012
1013   free(rcp->smf_tempo_track);
1014
1015   for ( t=0 ; t<RCP_MAX_TRACKS ; t++ ) {
1016     /*fprintf(stderr,"%d: %d\n", t, rcp->track[t].smf_ptr);*/
1017     if ( rcp->track[t].smf != NULL )
1018       free(rcp->track[t].smf);
1019   }
1020   rcp->smf_size = ptr;
1021   rcp->smf_data = smf_data;
1022
1023 #if 0
1024   smf_data[4] = (rcp->smf_size / (256*256*256)) % 256; /* Data length */
1025   smf_data[5] = (rcp->smf_size / (256*256)) % 256;
1026   smf_data[6] = (rcp->smf_size / 256) % 256;
1027   smf_data[7] = (rcp->smf_size) % 256;
1028 #endif
1029
1030   return smf_data;
1031 }
1032