DOOM64-RE

DOOM 64 Reverse Engineering
Log | Files | Refs | README | LICENSE

wesshand.c (17253B)


      1 
      2 /* ULTRA64 LIBRARIES */
      3 #include <ultra64.h>
      4 #include "ultratypes.h"
      5 #include <libaudio.h>
      6 
      7 /* WESS API INCLUDES */
      8 #include "wessapi.h"	// audio stuff...
      9 #include "seqload.h"
     10 #include "soundhw.h"
     11 #include "wessarc.h"
     12 #include "wessseq.h"
     13 
     14 #include "funqueue.h"
     15 
     16 #include "wessedit.h"
     17 #include "wesstrak.h"
     18 #include "wesshand.h"
     19 
     20 #ifndef NOUSEWESSCODE
     21 extern pmasterstat *pm_stat;			//0x800B41CC
     22 extern unsigned char CmdLength[36];
     23 extern unsigned char CmdSort[44];
     24 extern void(*DrvFunctions[36])(track_status *);
     25 
     26 /* used by wess trigger functions */
     27 enum HandleFlag { NoHandle, YesHandle };
     28 
     29 enum HandleStatus { HANDLE_INVALID, HANDLE_STOPPED, HANDLE_PLAYING };
     30 
     31 
     32 char scratch_area[32];//800B41E0
     33 
     34 void tracksetspecial(track_status *ptmp, TriggerPlayAttr *attr); // 8003429C
     35 void trackgetspecial(track_status *ptmp, TriggerPlayAttr *attr); // 80034508
     36 
     37 sequence_status *gethandleseq(int handle) // 80032E80
     38 {
     39 	char hindx;
     40 	sequence_status *psq;
     41 
     42 	if ((handle > 0) && (handle <= wess_driver_sequences))
     43 	{
     44 		hindx = handle - 1;
     45 		if ((psq = (pm_stat->pseqstattbl + hindx))->flags & SEQ_HANDLE)
     46 		{
     47 			return(psq);
     48 		}
     49 	}
     50 	return(NULL);
     51 }
     52 
     53 track_status *gethandletrk(int handle, int track) // 80032EE0
     54 {
     55 	char hindx;
     56 	sequence_status *psq;
     57 	track_status *ptrk;
     58 
     59 	if (handle > 0 && handle <= wess_driver_sequences)
     60 	{
     61 		hindx = handle - 1;
     62 		if ((psq = (pm_stat->pseqstattbl + hindx))->flags & SEQ_HANDLE)
     63 		{
     64 			if (*(psq->ptrk_indxs + track) != 0xFF)
     65 			{
     66 				if ((ptrk = pm_stat->ptrkstattbl + *(psq->ptrk_indxs + track))->flags & TRK_HANDLED)
     67 				{
     68 					return(ptrk);
     69 				}
     70 			}
     71 		}
     72 	}
     73 	return(NULL);
     74 }
     75 
     76 int wess_handle_get(int seq_num) // 80032F80
     77 {
     78 	sequence_data *psq_info;
     79 
     80 	if (!Is_Seq_Num_Valid(seq_num))
     81 		return(NULL);
     82 
     83 	psq_info = (pm_stat->pmod_info->pseq_info + seq_num);
     84 	return wess_seq_structrig(psq_info, seq_num, 0, YesHandle, NULL);
     85 }
     86 
     87 int wess_handle_status(int handle) // 80032FD8
     88 {
     89 	sequence_status *psq_stat;
     90 	int status;
     91 
     92 	if(!Is_Module_Loaded())
     93 		return HANDLE_INVALID;
     94 
     95 	psq_stat = gethandleseq(handle);
     96 
     97 	status = HANDLE_INVALID;
     98 	if (psq_stat)
     99 	{
    100 		if (psq_stat->playmode)
    101 		{
    102 			if (psq_stat->playmode == SEQ_STATE_STOPPED)
    103 				status = HANDLE_STOPPED;
    104 			else if (psq_stat->playmode == SEQ_STATE_PLAYING)
    105 				status = HANDLE_PLAYING;
    106 		}
    107 	}
    108 
    109 	return status;
    110 }
    111 
    112 void wess_handle_return(int handle) // 80033048
    113 {
    114 	sequence_status *psq_stat;
    115 	track_status *ptmp;
    116 
    117 	int li, lj;
    118 	char *lpdest;
    119 
    120 	int _handle;
    121 
    122 	_handle = handle;
    123 
    124 	if (!Is_Module_Loaded())
    125 		return;
    126 
    127 	wess_disable();
    128 
    129 	psq_stat = gethandleseq(_handle);
    130 
    131 	if (psq_stat)
    132 	{
    133 		li = psq_stat->tracks_active;
    134 		lj = pm_stat->max_trks_perseq;
    135 
    136 		/* *lpdest refers to an active track if not 0xFF */
    137 		lpdest = psq_stat->ptrk_indxs;
    138 		while (lj--)
    139 		{
    140 			if (*lpdest != 0xFF)
    141 			{
    142 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    143 				ptmp->flags &= ~TRK_HANDLED;
    144 				CmdFuncArr[ptmp->patchtype][TrkOff](ptmp);
    145 				if (!--li) break;
    146 			}
    147 			lpdest++;
    148 		}
    149 
    150 		psq_stat->flags &= ~SEQ_HANDLE;
    151 	}
    152 
    153 	wess_enable();
    154 
    155 	return;
    156 }
    157 
    158 void wess_handle_play_special(int handle, TriggerPlayAttr *attr) // 80033180
    159 {
    160 	sequence_status *psq_stat;
    161 	track_status *ptmp;
    162 
    163 	int li, lj;
    164 	char *lpdest;
    165 
    166 	int _handle;
    167 	TriggerPlayAttr *_attr;
    168 
    169 	_handle = handle;
    170 	_attr = attr;
    171 
    172 	if (!Is_Module_Loaded())
    173 		return;
    174 
    175 	wess_disable();
    176 
    177 	psq_stat = gethandleseq(_handle);
    178 
    179 	if (psq_stat)
    180 	{
    181 		li = psq_stat->tracks_active;
    182 		lj = pm_stat->max_trks_perseq;
    183 
    184 		/* *lpdest refers to an active track if not 0xFF */
    185 		lpdest = psq_stat->ptrk_indxs;
    186 		while (lj--)
    187 		{
    188 			if (*lpdest != 0xFF)
    189 			{
    190 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    191 				trackstart(ptmp, psq_stat);
    192 				tracksetspecial(ptmp, _attr);
    193 				if (!--li) break;
    194 			}
    195 			lpdest++;
    196 		}
    197 
    198 		psq_stat->playmode = SEQ_STATE_PLAYING;
    199 	}
    200 
    201 	wess_enable();
    202 
    203 	return;
    204 }
    205 
    206 void wess_handle_play(int handle) // 80033298()
    207 {
    208 	wess_handle_play_special(handle, 0);
    209 }
    210 
    211 void wess_handle_play_track_special(int handle, int track, TriggerPlayAttr *attr) // 800332B8
    212 {
    213 	sequence_status *psq_stat;
    214 	track_status *ptmp;
    215 
    216 	int _handle;
    217 	int _track;
    218 	TriggerPlayAttr *_attr;
    219 
    220 	_handle = handle;
    221 	_track = track;
    222 	_attr = attr;
    223 
    224 	if (!Is_Module_Loaded())
    225 		return;
    226 
    227 	wess_disable();
    228 
    229 	psq_stat = gethandleseq(_handle);
    230 
    231 	if (psq_stat)
    232 	{
    233 		ptmp = gethandletrk(_handle, _track);
    234 
    235 		if (ptmp)
    236 		{
    237 			trackstart(ptmp, psq_stat);
    238 			tracksetspecial(ptmp, _attr);
    239 		}
    240 	}
    241 
    242 	wess_enable();
    243 
    244 	return;
    245 }
    246 
    247 void wess_handle_play_track(int handle, int track) // 80033344
    248 {
    249 	wess_handle_play_track_special(handle, track, 0);
    250 	return;
    251 }
    252 
    253 void wess_handle_get_special(int handle, TriggerPlayAttr *attr) // 80033364
    254 {
    255 	sequence_status *psq_stat;
    256 	track_status *ptmp;
    257 
    258 	int li, lj;
    259 	char *lpdest;
    260 
    261 	int _handle;
    262 	TriggerPlayAttr *_attr;
    263 
    264 	_handle = handle;
    265 	_attr = attr;
    266 
    267 	if (!Is_Module_Loaded())
    268 		return;
    269 
    270 	wess_disable();
    271 
    272 	psq_stat = gethandleseq(_handle);
    273 
    274 	if (psq_stat)
    275 	{
    276 		li = psq_stat->tracks_active;
    277 		lj = pm_stat->max_trks_perseq;
    278 
    279 		/* *lpdest refers to an active track if not 0xFF */
    280 		lpdest = psq_stat->ptrk_indxs;
    281 		while (lj--)
    282 		{
    283 			if (*lpdest != 0xFF)
    284 			{
    285 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    286 				trackgetspecial(ptmp, _attr);
    287 				if (!--li) break;
    288 			}
    289 			lpdest++;
    290 		}
    291 	}
    292 
    293 	wess_enable();
    294 
    295 	return;
    296 }
    297 
    298 void wess_handle_set_special(int handle, TriggerPlayAttr *attr) // 80033454
    299 {
    300 	sequence_status *psq_stat;
    301 	track_status *ptmp;
    302 
    303 	int li, lj;
    304 	char *lpdest;
    305 
    306 	int _handle;
    307 	TriggerPlayAttr *_attr;
    308 
    309 	_handle = handle;
    310 	_attr = attr;
    311 
    312 	if (!Is_Module_Loaded())
    313 		return;
    314 
    315 	wess_disable();
    316 
    317 	psq_stat = gethandleseq(_handle);
    318 
    319 	if (psq_stat)
    320 	{
    321 		li = psq_stat->tracks_active;
    322 		lj = pm_stat->max_trks_perseq;
    323 
    324 		/* *lpdest refers to an active track if not 0xFF */
    325 		lpdest = psq_stat->ptrk_indxs;
    326 		while (lj--)
    327 		{
    328 			if (*lpdest != 0xFF)
    329 			{
    330 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    331 				tracksetspecial(ptmp, _attr);
    332 				if (!--li) break;
    333 			}
    334 			lpdest++;
    335 		}
    336 	}
    337 
    338 	wess_enable();
    339 
    340 	return;
    341 }
    342 
    343 void wess_handle_stop(int handle) // 80033544
    344 {
    345 	sequence_status *psq_stat;
    346 	track_status *ptmp;
    347 
    348 	int li, lj;
    349 	char *lpdest;
    350 
    351 	int _handle;
    352 
    353 	_handle = handle;
    354 
    355 	if (!Is_Module_Loaded())
    356 		return;
    357 
    358 	wess_disable();
    359 
    360 	psq_stat = gethandleseq(_handle);
    361 
    362 	if (psq_stat)
    363 	{
    364 		li = psq_stat->tracks_active;
    365 		lj = pm_stat->max_trks_perseq;
    366 
    367 		/* *lpdest refers to an active track if not 0xFF */
    368 		lpdest = psq_stat->ptrk_indxs;
    369 		while (lj--)
    370 		{
    371 			if (*lpdest != 0xFF)
    372 			{
    373 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    374 				CmdFuncArr[ptmp->patchtype][TrkOff](ptmp);
    375 				if (!--li) break;
    376 			}
    377 			lpdest++;
    378 		}
    379 	}
    380 
    381 	wess_enable();
    382 
    383 	return;
    384 }
    385 
    386 void wess_handle_fastsettempo(int handle, short tempo) // 80033658
    387 {
    388 	sequence_status *psq_stat;
    389 	track_status *ptmp;
    390 
    391 	int li, lj;
    392 	char *lpdest;
    393 	unsigned long ppi;
    394 
    395 	int _handle;
    396 	short _tempo;
    397 
    398 	_handle = handle;
    399 	_tempo = tempo;
    400 
    401 	if (!Is_Module_Loaded())
    402 		return;
    403 
    404 	wess_disable();
    405 
    406 	psq_stat = gethandleseq(_handle);
    407 	ppi = 0;
    408 
    409 	if (psq_stat)
    410 	{
    411 		li = psq_stat->tracks_active;
    412 		lj = pm_stat->max_trks_perseq;
    413 
    414 		/* *lpdest refers to an active track if not 0xFF */
    415 		lpdest = psq_stat->ptrk_indxs;
    416 		while (lj--)
    417 		{
    418 			if (*lpdest != 0xFF)
    419 			{
    420 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    421 				ptmp->qpm = _tempo;
    422 				if (ppi == 0)
    423 					ppi = CalcPartsPerInt(GetIntsPerSec(), ptmp->ppq, ptmp->qpm);
    424 				ptmp->ppi = ppi;
    425 
    426 				if (!--li) break;
    427 			}
    428 			lpdest++;
    429 		}
    430 	}
    431 
    432 	wess_enable();
    433 
    434 	return;
    435 }
    436 
    437 int wess_handle_fade(void) // 80033788
    438 {
    439 	return Is_Module_Loaded();
    440 }
    441 
    442 void wess_handle_resetposition(int handle) // 800337B0
    443 {
    444 	sequence_status *psq_stat;
    445 	track_status *ptmp;
    446 
    447 	int li, lj;
    448 	char *lpdest;
    449 
    450 	int _handle;
    451 
    452 	_handle = handle;
    453 
    454 	if (!Is_Module_Loaded())
    455 		return;
    456 
    457 	wess_disable();
    458 
    459 	psq_stat = gethandleseq(_handle);
    460 
    461 	if (psq_stat)
    462 	{
    463 		li = psq_stat->tracks_active;
    464 		lj = pm_stat->max_trks_perseq;
    465 
    466 		/* *lpdest refers to an active track if not 0xFF */
    467 		lpdest = psq_stat->ptrk_indxs;
    468 		while (lj--)
    469 		{
    470 			if (*lpdest != 0xFF)
    471 			{
    472 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    473 				CmdFuncArr[ptmp->patchtype][TrkMute](ptmp);
    474 
    475 				ptmp->starppi = 0;
    476 				ptmp->totppi = 0;
    477 				ptmp->ppos = Read_Vlq(ptmp->pstart, &ptmp->deltatime);
    478 
    479 				if (!--li) break;
    480 			}
    481 			lpdest++;
    482 		}
    483 	}
    484 
    485 	wess_enable();
    486 	return;
    487 }
    488 
    489 int wess_track_gotoposition(track_status *ptmp, int position, char *ppos) // 800338F0
    490 {
    491 	int deltatime;
    492 	int status;
    493 	int accppi;
    494 
    495 
    496 	deltatime = ptmp->deltatime;
    497 	accppi = ptmp->totppi + (ptmp->starppi >> 16);
    498 
    499 	while (1)
    500 	{
    501 		accppi += deltatime;
    502 
    503 		if (position <= accppi)
    504 		{
    505 			status = 1;
    506 			break;
    507 		}
    508 
    509 		if (*ptmp->ppos == TrkEnd)
    510 		{
    511 			status = 0;
    512 			break;
    513 		}
    514 
    515 		if (*ptmp->ppos == NoteOn || *ptmp->ppos == NoteOff)
    516 		{
    517 			ptmp->ppos += CmdLength[*ptmp->ppos];
    518 			ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime);
    519 			continue;
    520 		}
    521 		else
    522 		{
    523 			if ((*ptmp->ppos < PatchChg) || (*ptmp->ppos > NoteOff))
    524 			{
    525 				if ((*ptmp->ppos < StatusMark) || (*ptmp->ppos > NullEvent))
    526 				{
    527 					Eng_SeqEnd(ptmp);
    528 				}
    529 				else
    530 				{
    531 					DrvFunctions[*ptmp->ppos](ptmp);
    532 
    533 					if (ptmp->flags & TRK_SKIP)
    534 					{
    535 						ptmp->flags &= ~TRK_SKIP;
    536 					}
    537 					else
    538 					{
    539 						ptmp->ppos += CmdLength[*ptmp->ppos];
    540 						ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime);
    541 					}
    542 				}
    543 			}
    544 			else
    545 			{
    546 				CmdFuncArr[ptmp->patchtype][*ptmp->ppos](ptmp);
    547 				ptmp->ppos += CmdLength[*ptmp->ppos];
    548 				ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime);
    549 			}
    550 		}
    551 	}
    552 
    553 	if (status)
    554 	{
    555 		ptmp->deltatime = accppi - position;
    556 		ptmp->starppi = 0;
    557 		ptmp->totppi = position;
    558 	}
    559 	else
    560 	{
    561 		ptmp->deltatime = 0;
    562 		ptmp->starppi = 0;
    563 		ptmp->totppi = accppi;
    564 	}
    565 
    566 	ppos = ptmp->ppos;
    567 
    568 	return ptmp->totppi;
    569 }
    570 
    571 int wess_track_setposition(track_status *ptmp, int position, char *ppos) // 80033B24
    572 {
    573 	int deltatime;
    574 	int val;
    575 	int accppi;
    576 	int status;
    577 
    578 	deltatime = 0;
    579 	accppi = 0;
    580 	ptmp->ppos = ptmp->pstart;
    581 	ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime);
    582 
    583 	while (1)
    584 	{
    585 		accppi += deltatime;
    586 
    587 		if (position <= accppi)
    588 		{
    589 			status = 1;
    590 			break;
    591 		}
    592 
    593 		if (*ptmp->ppos == TrkEnd)
    594 		{
    595 			status = 0;
    596 			break;
    597 		}
    598 
    599 		if (*ptmp->ppos == NoteOn || *ptmp->ppos == NoteOff)
    600 		{
    601 			ptmp->ppos += CmdLength[*ptmp->ppos];
    602 			ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime);
    603 			continue;
    604 		}
    605 		else
    606 		{
    607 			if ((*ptmp->ppos < PatchChg) || (*ptmp->ppos > NoteOff))
    608 			{
    609 				if ((*ptmp->ppos < StatusMark) || (*ptmp->ppos > NullEvent))
    610 				{
    611 					Eng_SeqEnd(ptmp);
    612 				}
    613 				else
    614 				{
    615 					DrvFunctions[*ptmp->ppos](ptmp);
    616 
    617 					if (ptmp->flags & TRK_SKIP)
    618 					{
    619 						ptmp->flags &= ~TRK_SKIP;
    620 					}
    621 					else
    622 					{
    623 						ptmp->ppos += CmdLength[*ptmp->ppos];
    624 						ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime);
    625 					}
    626 				}
    627 			}
    628 			else
    629 			{
    630 				CmdFuncArr[ptmp->patchtype][*ptmp->ppos](ptmp);
    631 				ptmp->ppos += CmdLength[*ptmp->ppos];
    632 				ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime);
    633 			}
    634 		}
    635 	}
    636 
    637 	if (status)
    638 	{
    639 		ptmp->deltatime = (accppi - position);
    640 		ptmp->starppi = 0;
    641 		ptmp->totppi = position;
    642 	}
    643 	else
    644 	{
    645 		ptmp->deltatime = 0;
    646 		ptmp->starppi = 0;
    647 		ptmp->totppi = accppi;
    648 	}
    649 
    650 	ppos = ptmp->ppos;
    651 
    652 	return ptmp->totppi;
    653 }
    654 
    655 int wess_handle_advposition(int handle, int position) // 80033D58
    656 {
    657 	sequence_status *psq_stat;
    658 	track_status *ptmp;
    659 	char ppos[12];
    660 
    661 	int li, lj;
    662 	char *lpdest;
    663 
    664 	int _handle, _position;
    665 
    666 	_handle = handle;
    667 	_position = position;
    668 
    669 	if (!Is_Module_Loaded())
    670 		return 0;
    671 
    672 	wess_disable();
    673 
    674 	psq_stat = gethandleseq(_handle);
    675 
    676 	if (psq_stat)
    677 	{
    678 		li = psq_stat->tracks_active;
    679 		lj = pm_stat->max_trks_perseq;
    680 
    681 		/* *lpdest refers to an active track if not 0xFF */
    682 		lpdest = psq_stat->ptrk_indxs;
    683 		while (lj--)
    684 		{
    685 			if (*lpdest != 0xFF)
    686 			{
    687 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    688 				CmdFuncArr[ptmp->patchtype][TrkMute](ptmp);
    689 				wess_track_gotoposition(ptmp, ptmp->totppi + _position, ppos);
    690 				if (!--li) break;
    691 			}
    692 			lpdest++;
    693 		}
    694 	}
    695 
    696 	wess_enable();
    697 	return wess_handle_getposition(_handle);
    698 }
    699 
    700 int wess_handle_setposition(int handle, int position) // 80033EB8
    701 {
    702 	sequence_status *psq_stat;
    703 	track_status *ptmp;
    704 	char ppos[12];
    705 
    706 	int li, lj;
    707 	char *lpdest;
    708 
    709 	int _handle, _position;
    710 
    711 	_handle = handle;
    712 	_position = position;
    713 
    714 	if (!Is_Module_Loaded())
    715 		return 0;
    716 
    717 	wess_disable();
    718 
    719 	psq_stat = gethandleseq(_handle);
    720 
    721 	if (psq_stat)
    722 	{
    723 		li = psq_stat->tracks_active;
    724 		lj = pm_stat->max_trks_perseq;
    725 
    726 		/* *lpdest refers to an active track if not 0xFF */
    727 		lpdest = psq_stat->ptrk_indxs;
    728 		while (lj--)
    729 		{
    730 			if (*lpdest != 0xFF)
    731 			{
    732 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    733 				CmdFuncArr[ptmp->patchtype][TrkMute](ptmp);
    734 				wess_track_setposition(ptmp, _position, ppos);
    735 				if (!--li) break;
    736 			}
    737 			lpdest++;
    738 		}
    739 	}
    740 
    741 	wess_enable();
    742 	return wess_handle_getposition(_handle);
    743 }
    744 
    745 int wess_handle_getposition(int handle) // 80034010
    746 {
    747 	sequence_status *psq_stat;
    748 	track_status *ptmp;
    749 
    750 	int li, lj;
    751 	char *lpdest;
    752 	int position;
    753 
    754 	int _handle;
    755 
    756 	_handle = handle;
    757 
    758 	position = 0;
    759 
    760 	if (!Is_Module_Loaded())
    761 		return 0;
    762 
    763 	wess_disable();
    764 
    765 	psq_stat = gethandleseq(_handle);
    766 
    767 	if (psq_stat)
    768 	{
    769 		li = psq_stat->tracks_active;
    770 		lj = pm_stat->max_trks_perseq;
    771 
    772 		/* *lpdest refers to an active track if not 0xFF */
    773 		lpdest = psq_stat->ptrk_indxs;
    774 		while (lj--)
    775 		{
    776 			if (*lpdest != 0xFF)
    777 			{
    778 				ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    779 				if(position < ptmp->totppi)
    780 					position = ptmp->totppi;
    781 
    782 				if (!--li) break;
    783 			}
    784 			lpdest++;
    785 		}
    786 	}
    787 
    788 	wess_enable();
    789 
    790 	return position;
    791 }
    792 
    793 void patch_chg_action(track_status *ptmp, int patch_num) // 800340E0
    794 {
    795 	ptmp->ppos[0] = PatchChg;
    796 	ptmp->ppos[1] = patch_num;
    797 	ptmp->ppos[2] = patch_num >> 8;
    798 	CmdFuncArr[ptmp->patchtype][PatchChg](ptmp);
    799 }
    800 
    801 void pitch_mod_action(track_status *ptmp, int pitch_cntr) // 80034144
    802 {
    803 	ptmp->ppos[0] = PitchMod;
    804 	ptmp->ppos[1] = pitch_cntr;
    805 	ptmp->ppos[2] = pitch_cntr >> 8;
    806 	CmdFuncArr[ptmp->patchtype][PitchMod](ptmp);
    807 }
    808 
    809 void volume_mod_action(track_status *ptmp, int volume_cntr) // 800341A8
    810 {
    811 	ptmp->ppos[0] = VolumeMod;
    812 	ptmp->ppos[1] = volume_cntr;
    813 	CmdFuncArr[ptmp->patchtype][VolumeMod](ptmp);
    814 }
    815 
    816 void pan_mod_action(track_status *ptmp, int pan_cntr) // 80034200
    817 {
    818 	ptmp->ppos[0] = PanMod;
    819 	ptmp->ppos[1] = pan_cntr;
    820 	CmdFuncArr[ptmp->patchtype][PanMod](ptmp);
    821 }
    822 
    823 void wess_track_parm_mod(track_status *ptmp, int value, WessAction funcion) // 80034258
    824 {
    825 	char *ppos;
    826 
    827 	//save
    828 	ppos = ptmp->ppos;
    829 	ptmp->ppos = scratch_area;
    830 	funcion(ptmp, value);
    831 	//restore
    832 	ptmp->ppos = ppos;
    833 }
    834 
    835 void tracksetspecial(track_status *ptmp, TriggerPlayAttr *attr) // 8003429C
    836 {
    837 	int mask;
    838 
    839 	ptmp->flags &= ~(TRK_TIMED | TRK_LOOPED);
    840 
    841 	if (attr != NULL)
    842 	{
    843 		mask = attr->mask;
    844 		if (mask)
    845 		{
    846 			if (mask & TRIGGER_VOLUME)
    847 			{
    848 				ptmp->volume_cntrl = attr->volume;
    849 				wess_track_parm_mod(ptmp, attr->volume, volume_mod_action);
    850 
    851 				mask &= ~TRIGGER_VOLUME;
    852 				if (!(mask))
    853 					return;
    854 			}
    855 
    856 			if (mask & TRIGGER_PAN)
    857 			{
    858 				ptmp->pan_cntrl = attr->pan;
    859 				wess_track_parm_mod(ptmp, attr->pan, pan_mod_action);
    860 
    861 				mask &= ~TRIGGER_PAN;
    862 				if (!(mask))
    863 					return;
    864 			}
    865 
    866 			if (mask & TRIGGER_PATCH)
    867 			{
    868 				ptmp->patchnum = attr->patch;
    869 				wess_track_parm_mod(ptmp, attr->patch, patch_chg_action);
    870 
    871 				mask &= ~TRIGGER_PATCH;
    872 				if (!(mask))
    873 					return;
    874 			}
    875 
    876 			if (mask & TRIGGER_PITCH)
    877 			{
    878 				ptmp->pitch_cntrl = attr->pitch;
    879 				wess_track_parm_mod(ptmp, attr->pitch, pitch_mod_action);
    880 
    881 				mask &= ~TRIGGER_PITCH;
    882 				if (!(mask))
    883 					return;
    884 			}
    885 
    886 			if (mask & TRIGGER_MUTEMODE)
    887 			{
    888 				if (ptmp->mutemask & (1 << attr->mutemode))
    889 				{
    890 					ptmp->flags |= TRK_MUTE;
    891 					CmdFuncArr[ptmp->patchtype][TrkMute](ptmp);
    892 				}
    893 				ptmp->flags &= ~TRK_MUTE;
    894 
    895 				mask &= ~TRIGGER_MUTEMODE;
    896 				if (!(mask))
    897 					return;
    898 			}
    899 
    900 			if (mask & TRIGGER_TEMPO)
    901 			{
    902 				ptmp->qpm = attr->tempo;
    903 				ptmp->ppi = CalcPartsPerInt(GetIntsPerSec(), ptmp->ppq, ptmp->qpm);
    904 
    905 				mask &= ~TRIGGER_TEMPO;
    906 				if (!(mask))
    907 					return;
    908 			}
    909 
    910 			if (mask & TRIGGER_TIMED)
    911 			{
    912 				ptmp->endppi = ptmp->totppi + attr->timeppq;
    913 				ptmp->flags |= TRK_TIMED;
    914 
    915 				mask &= ~TRIGGER_TIMED;
    916 				if (!(mask))
    917 					return;
    918 			}
    919 
    920 			if (mask & TRIGGER_LOOPED)
    921 			{
    922 				ptmp->flags |= TRK_LOOPED;
    923 			}
    924 		}
    925 	}
    926 }
    927 
    928 void trackgetspecial(track_status *ptmp, TriggerPlayAttr *attr) // 80034508
    929 {
    930 	int mask;
    931 
    932 	mask = attr->mask;
    933 
    934 	if (mask)
    935 	{
    936 		if (mask & TRIGGER_VOLUME)
    937 		{
    938 			attr->volume = ptmp->volume_cntrl;
    939 			mask &= ~TRIGGER_VOLUME;
    940 			if (!(mask))
    941 				return;
    942 		}
    943 
    944 		if (mask & TRIGGER_PAN)
    945 		{
    946 			attr->pan = ptmp->pan_cntrl;
    947 			mask &= ~TRIGGER_PAN;
    948 			if (!(mask))
    949 				return;
    950 		}
    951 
    952 		if (mask & TRIGGER_PATCH)
    953 		{
    954 			attr->patch = ptmp->patchnum;
    955 			mask &= ~TRIGGER_PATCH;
    956 			if (!(mask))
    957 				return;
    958 		}
    959 
    960 		if (mask & TRIGGER_PITCH)
    961 		{
    962 			attr->pitch = ptmp->pitch_cntrl;
    963 			mask &= ~TRIGGER_PITCH;
    964 			if (!(mask))
    965 				return;
    966 		}
    967 
    968 		if (mask & TRIGGER_MUTEMODE)
    969 		{
    970 			attr->mutemode = ptmp->mutemask;
    971 			mask &= ~TRIGGER_MUTEMODE;
    972 			if (!(mask))
    973 				return;
    974 		}
    975 
    976 		if (mask & TRIGGER_TEMPO)
    977 		{
    978 			attr->tempo = ptmp->qpm;
    979 			mask &= ~TRIGGER_TEMPO;
    980 			if (!(mask))
    981 				return;
    982 		}
    983 
    984 		if (mask & TRIGGER_TIMED)
    985 		{
    986 			if (!(ptmp->flags & TRK_TIMED))
    987 				attr->mask &= ~TRIGGER_TIMED;
    988 			else
    989 				attr->timeppq = ptmp->endppi - ptmp->totppi;
    990 
    991 			mask &= ~TRIGGER_TIMED;
    992 			if (!(mask))
    993 				return;
    994 		}
    995 
    996 		if (mask & TRIGGER_LOOPED)
    997 		{
    998 			if (!(ptmp->flags & TRK_LOOPED))
    999 				attr->mask &= ~TRIGGER_LOOPED;
   1000 		}
   1001 	}
   1002 }
   1003 #endif // 0