wrd_read.c

MIDI解码程序(用VC编写)

	    return WRD_GLINE;
	if(cmd[3] == 'D')
	    return WRD_GMODE;
	return WRD_GMOVE;
      case 'I':
	return WRD_INKEY;
      case 'L':
	if(cmd[2] == 'C')
	    return WRD_LOCATE;
	if(cmd[2] == 'N')
	    return WRD_eLINE;
	return WRD_LOOP;
      case 'M':
	if(cmd[1] == 'A')
	    return WRD_MAG;
	return WRD_MIDI;
      case 'O':
	return WRD_OFFSET;
      case 'P':
	if(cmd[3] == '\0')
	    return WRD_PAL;
	if(cmd[1] == 'L')
	    return WRD_PLOAD;
	if(cmd[2] == 'T')
	    return WRD_PATH;
	if(cmd[3] == 'C')
	    return WRD_PALCHG;
	return WRD_PALREV;
      case 'R':
	if(cmd[2] == 'G')
	    return WRD_eREGSAVE;
	if(cmd[2] == 'S')
	    return WRD_REST;
	if(cmd[3] == 'A')
	    return WRD_REMARK;
	return WRD_REM;
      case 'S':
	if(cmd[3] == 'E')
	    return WRD_SCREEN;
	if(cmd[3] == 'O')
	    return WRD_SCROLL;
	if(cmd[3] == 'R')
	    return WRD_STARTUP;
	return WRD_STOP;
      case 'T':
	if(cmd[1] == 'C')
	    return WRD_TCLS;
	if(cmd[1] == 'E')
	    return WRD_eTEXTDOT;
	if(cmd[1] == 'M')
	    return WRD_eTMODE;
	if(cmd[1] == 'O')
	    return WRD_TON;
	return WRD_eTSCRL;
      case 'V':
	if(cmd[2] == 'O')
	    return WRD_eVCOPY;
	if(cmd[2] == 'G')
	    return WRD_eVSGET;
	return WRD_eVSRES;
      case 'W':
	if(cmd[1] == 'A')
	    return WRD_WAIT;
	return WRD_WMODE;
      case 'X':
	return WRD_eXCOPY;
    }
    return 0;
}

static int wrd_split(char* arg, char** argv, int maxarg)
{
    int i, j;

#if defined(ABORT_AT_FATAL) || defined(DEBUG)
    if(maxarg < 2) {
	fprintf(stderr,
		"wrd_read.c: wrd_split(): maxarg must be more than 1.\n");
	abort();
    }
#endif

    for(i = 0; *arg && i < maxarg; i++)
    {
	argv[i] = arg;
	while(*arg && *arg != ',' && *arg != ';')
	    arg++;
	if(!*arg)
	{
	    i++;
	    break;
	}
	*arg++ = '\0';
    }
    for(j = i; j < maxarg; j++)
	argv[j] = "";
    return i;
}

#ifdef DEBUG
static char *wrd_name_string(int cmd)
{
    switch(cmd)
    {
#define WRDCASE(cmd) case WRD_ ## cmd: return #cmd
	WRDCASE(COMMAND);
	WRDCASE(ECOMMAND);
	WRDCASE(STEP);
	WRDCASE(LYRIC);
	WRDCASE(EOF);
	WRDCASE(COLOR);
	WRDCASE(END);
	WRDCASE(ESC);
	WRDCASE(EXEC);
	WRDCASE(FADE);
	WRDCASE(GCIRCLE);
	WRDCASE(GCLS);
	WRDCASE(GINIT);
	WRDCASE(GLINE);
	WRDCASE(GMODE);
	WRDCASE(GMOVE);
	WRDCASE(GON);
	WRDCASE(GSCREEN);
	WRDCASE(INKEY);
	WRDCASE(LOCATE);
	WRDCASE(LOOP);
	WRDCASE(MAG);
	WRDCASE(MIDI);
	WRDCASE(OFFSET);
	WRDCASE(PAL);
	WRDCASE(PALCHG);
	WRDCASE(PALREV);
	WRDCASE(PATH);
	WRDCASE(PLOAD);
	WRDCASE(REM);
	WRDCASE(REMARK);
	WRDCASE(REST);
	WRDCASE(SCREEN);
	WRDCASE(SCROLL);
	WRDCASE(STARTUP);
	WRDCASE(STOP);
	WRDCASE(TCLS);
	WRDCASE(TON);
	WRDCASE(WAIT);
	WRDCASE(WMODE);
	WRDCASE(eFONTM);
	WRDCASE(eFONTP);
	WRDCASE(eFONTR);
	WRDCASE(eGSC);
	WRDCASE(eLINE);
	WRDCASE(ePAL);
	WRDCASE(eREGSAVE);
	WRDCASE(eSCROLL);
	WRDCASE(eTEXTDOT);
	WRDCASE(eTMODE);
	WRDCASE(eTSCRL);
	WRDCASE(eVCOPY);
	WRDCASE(eVSGET);
	WRDCASE(eVSRES);
	WRDCASE(eXCOPY);
	WRDCASE(ARG);
	WRDCASE(FADESTEP);
	WRDCASE(OUTKEY);
	WRDCASE(NL);
	WRDCASE(MAGPRELOAD);
	WRDCASE(PHOPRELOAD);
	WRDCASE(START_SKIP);
	WRDCASE(END_SKIP);
	WRDCASE(NOARG);
#undef WRDCASE
    }
    return "Unknown";
}
#endif /* DEBUG */

#ifdef ENABLE_SHERRY
/*******************************************************************************/
#pragma mark -

static int sherry_started;	/* 0 - before start command 0x01*/
				/* 1 - after start command 0x01*/

static int sry_timebase_mode = 0; /* 0 is default */

static int32 sry_getVariableLength(struct timidity_file	*tf)
{
  int32 value= 0;
  int tmp;
  do
    {
      tmp = tf_getc(tf);
      if(tmp == EOF)
	  return -1;
      value = (value << 7) + (tmp&0x7f);
    }while ((tmp&0x80) != 0);
  return value;
}

static int sry_check_head(struct timidity_file	*tf)
{
	char	magic[12];
	uint8	version[4];
	
	tf_read(magic, 12,1,tf);
	if( memcmp(magic, "Sherry WRD\0\0", 12) ){
		ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
			  "Sherry open::Header NG." );
		return 1;
	}
	tf_read(version, 1, 4, tf);
	ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
		  "Sherry WRD version: %02x %02x %02x %02x",
		  version[0], version[1], version[2], version[3]);

	return 0;	/*good*/
}

struct sry_drawtext_{
	char	op;
	short	v_plane;
	char	mask;
	char	mode;
	char	fore_color;
	char	back_color;
	short	x;
	short	y;
	char	*text;
};
typedef struct sry_drawtext_ sry_drawtext;

static void sry_regist_datapacket( struct wrd_step_tracer* wrdstep,
					const sry_datapacket* packet)
{
    int a, b, c;
    int err = 0;

    if(datapacket == NULL)
    {
	datapacket = (sry_datapacket *)safe_malloc(DEFAULT_DATAPACKET_LEN *
						   sizeof(sry_datapacket));
	datapacket_len = DEFAULT_DATAPACKET_LEN;
	datapacket_cnt = 0;
    }
    else
    {
	if(datapacket_cnt == (1<<24)-1) /* Over flow */
	    err = 1;
	else
	{
	    if(datapacket_cnt >= datapacket_len)
	    {
		datapacket_len *= 2;
		datapacket = (sry_datapacket *)
		    safe_realloc(datapacket,
				 datapacket_len * sizeof(sry_datapacket));
	    }
	}
    }

    a = datapacket_cnt & 0xff;
    b = (datapacket_cnt >> 8) & 0xff;
    c = (datapacket_cnt >> 16) & 0xff;
    datapacket[datapacket_cnt] = *packet;
    MIDIEVENT(wrdstep->at, ME_SHERRY, a, b, c);

    if(err)
	datapacket[datapacket_cnt].data[0] = 0xff;
    else
	datapacket_cnt++;
}

static int sry_read_datapacket(struct timidity_file	*tf, sry_datapacket* packet)
{
	int	len;
	uint8	*data;

	do
	{
	    len = sry_getVariableLength(tf);
	    if(len < 0)
	    {
		ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
			  "Warning: Too shorten Sherry WRD file.");
		return 1;
	    }
	} while(len == 0);
	data = 	(uint8 *)new_segment(&sry_pool, len + 1);
	if(tf_read(data, 1, len, tf) < len)
	{
	    ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
		      "Warning: Too shorten Sherry WRD file.");
	    return 1;
	}
	data[len]=0;
	packet->len= len;
	packet->data= data;
	return 0;
}

static void sry_timebase21(struct wrd_step_tracer* wrdstep, int timebase)
{
    sherry_started=0;
    memset(wrdstep, 0, sizeof(struct wrd_step_tracer));
    init_mblock(&wrdstep->pool);
    wrdstep->de = wrdstep->free_de = NULL;
    wrdstep->timebase = timebase; /* current_file_info->divisions; */
    wrdstep->ntimesig = dump_current_timesig(wrdstep->timesig, MAXTIMESIG - 1);
    if(wrdstep->ntimesig > 0)
    {
	wrdstep->timesig[wrdstep->ntimesig] =
	    wrdstep->timesig[wrdstep->ntimesig - 1];
	wrdstep->timesig[wrdstep->ntimesig].time = 0x7fffffff; /* stopper */
#ifdef DEBUG
	{
	int i;
	printf("Time signatures:\n");
	for(i = 0; i < wrdstep->ntimesig; i++)
	    printf("  %d: %d/%d\n",
		   wrdstep->timesig[i].time,
		   wrdstep->timesig[i].a,
		   wrdstep->timesig[i].b);
	}
#endif /* DEBUG */
	wrdstep->barstep =
	    wrdstep->timesig[0].a * wrdstep->timebase * 4 / wrdstep->timesig[0].b;
    }
    else
	wrdstep->barstep = 4 * wrdstep->timebase;
    wrdstep->step_inc = wrdstep->barstep;
    wrdstep->last_at = readmidi_set_track(0, 0);

    readmidi_set_track(0, 1);
    /* wrdstep.step_inc = wrdstep.timebase; */

#ifdef DEBUG
    printf("Timebase: %d, divisions:%d\n",
    		wrdstep->timebase, current_file_info->divisions);
    printf("Step: %d\n", wrdstep->step_inc);
#endif /* DEBUG */
}

static void sry_timebase22(struct wrd_step_tracer* wrdstep, int mode)
{
    sry_timebase_mode = mode;
    if(sry_timebase_mode)
	ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
		  "Sherry time synchronize mode is not supported");
}

static void sry_wrdinfo(uint8 *info, int len)
{
    uint8 *info1, *info2, *desc;
    int i;

    /* "info1\0info2\0desc\0" */
    /* FIXME: Need to convert SJIS to "output_text_code" */

    i = 0;
    info1 = info;
    while(i < len && info[i])
	i++;
    i++; /* skip '\0' */
    if(i >= len)
	return;
    info2 = info + i;
    while(i < len && info[i])
	i++;
    i++; /* skip '\0' */
    if(i >= len)
	return;
    desc = info + i;

    ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
	      "Sherry WRD: %s: %s: %s", info1, info2, desc);
}

static void sry_show_debug(uint8 *data)
{
    switch(data[0])
    {
      case 0x71: /* Compiler name */
	if(data[1])
	    ctl->cmsg(CMSG_INFO, VERB_NOISY,
		      "Sherry WRD Compiler: %s", data + 1);
	break;
      case 0x72: /* Source Name */
	if(data[1])
	    ctl->cmsg(CMSG_INFO, VERB_NOISY,
		      "Sherry WRD Compiled from %s", data + 1);
	break;
      case 0x7f: /* Compiler Private */
	break;
    }
}

static void sry_read_headerblock(struct wrd_step_tracer* wrdstep,
					struct timidity_file *tf)
{
	sry_datapacket	packet;
	int err;

	packet.len = 1;
	packet.data = (uint8 *)new_segment(&sry_pool, 1);
	packet.data[0] = 0x01;
	sry_regist_datapacket(wrdstep , &packet);
	
	for(;;){
		err= sry_read_datapacket(tf, &packet);
		if( err ) break;
		sry_regist_datapacket(wrdstep , &packet);
		switch(packet.data[0])
		{
		  case 0x00: /* end of header */
		    return;
		  case 0x20:
		    if( mimpi_bug_emulation_level >= 1 ){
		      sry_timebase21(wrdstep, SRY_GET_SHORT(packet.data+1));
		    }
		    break;
		  case 0x21:
		    sry_timebase21(wrdstep, SRY_GET_SHORT(packet.data+1));
		    break;
		  case 0x22:
		    sry_timebase22(wrdstep, packet.data[1]);
		    break;
		  case 0x61:
		    sry_wrdinfo(packet.data + 1, packet.len - 1);
		    break;
		  default:
		    if((packet.data[0] & 0x70) == 0x70)
			sry_show_debug(packet.data);
		    break;
		}
	}
}

static void sry_read_datablock(struct wrd_step_tracer* wrdstep,
				  struct timidity_file	*tf)
{
    sry_datapacket  packet;
    int		    delta_time; /*, cur_time=0; */
    int		    err;
    int		    need_update;

    need_update = 0;
    for(;;){
		delta_time= sry_getVariableLength(tf);
		if(delta_time > 0 && need_update)
		{
		    WRD_ADDEVENT(wrdstep->at, WRD_SHERRY_UPDATE, WRD_NOARG);
		    need_update = 0;
		}
		err = sry_read_datapacket(tf, &packet);
		if( err ) break;
		/* cur_time =+ delta_time;*/
		/* wrdstep_wait(wrdstep, delta_time,0); */
		/* wrdstep_setstep(wrdstep, delta_time); */

		if( sherry_started && delta_time ){
		    wrdstep_inc(wrdstep,
				delta_time*current_file_info->divisions
				/wrdstep->timebase);
		}

		if( packet.data[0]==0x01 ){
			sherry_started=1;
			continue;
		} else if( (packet.data[0]&0x70) == 0x70) {
		    sry_show_debug(packet.data);
		}

		sry_regist_datapacket(wrdstep , &packet);
		if(packet.data[0] == 0x31 ||
		   packet.data[0] == 0x35 ||
		   packet.data[0] == 0x36)
		    need_update = 1;

		if( packet.data[0] == 0x00 ) break;
    }
    if(need_update)
    {
	WRD_ADDEVENT(wrdstep->at, WRD_SHERRY_UPDATE, WRD_NOARG);
	need_update = 0;
    }
}

static int import_sherrywrd_file(const char * fn)
{
	char	sry_fn[256];
	char	*cp;
	struct timidity_file	*tf;
    struct wrd_step_tracer wrdstep;
	
	strncpy(sry_fn, fn, sizeof(sry_fn));
	cp=strrchr(sry_fn, '.');
	if( cp==0 ) return 0;
	
	strncpy(cp+1, "sry", sizeof(sry_fn) - (cp - sry_fn) - 1);
	tf= open_file( sry_fn, 0, OF_NORMAL);
	if( tf==NULL ) return 0;
	if( sry_check_head(tf)!=0 ) return 0;
	ctl->cmsg(CMSG_INFO, VERB_NORMAL,
		  "%s: reading sherry data...", sry_fn);
	
	wrd_readinit();
	memset(&wrdstep, 0, sizeof(wrdstep));

/**********************/
/*    MIDIEVENT(0, ME_SHERRY_START, 0, 0, 0); */
    sry_read_headerblock( &wrdstep, tf);
    sry_read_datablock( &wrdstep, tf);

/*  end_of_wrd: */
    while(wrdstep.de)
    {
	wrdstep_nextbar(&wrdstep);
    }
    reuse_mblock(&wrdstep.pool);
    close_file(tf);
#ifdef DEBUG
    fflush(stdout);
#endif /* DEBUG */
    return 1;
}

#endif /*ENABLE_SHERRY*/