DOOM64-RE

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

wessapip.c (10431B)


      1 
      2 /* WESS API INCLUDES */
      3 #include "wessapi.h"	// audio stuff...
      4 #include "seqload.h"
      5 #include "soundhw.h"
      6 #include "wessarc.h"
      7 #include "wessseq.h"
      8 
      9 #include "funqueue.h"
     10 
     11 #include "graph.h" // debug
     12 #ifndef NOUSEWESSCODE
     13 extern pmasterstat *pm_stat;    //0x800B41CC
     14 
     15 void trackstart(track_status *ptmp, sequence_status *psq_stat) // 80031650
     16 {
     17 	if (ptmp->flags & TRK_STOPPED)
     18 	{
     19 		ptmp->flags &= ~(TRK_MUTE|TRK_STOPPED);
     20 		if (++psq_stat->tracks_playing)
     21 		{
     22 			psq_stat->playmode = SEQ_STATE_PLAYING;
     23 		}
     24 	}
     25 }
     26 
     27 void trackstop(track_status *ptmp, sequence_status *psq_stat) // 800316A0
     28 {
     29 	if (!(ptmp->flags & TRK_STOPPED))
     30 	{
     31 		ptmp->flags |= (TRK_MUTE|TRK_STOPPED);
     32 		if (!--psq_stat->tracks_playing)
     33 		{
     34 			psq_stat->playmode = SEQ_STATE_STOPPED;
     35 		}
     36 	}
     37 }
     38 
     39 void wess_seq_pause(int sequence_number, enum MuteFlag mflag) // 800316F0
     40 {
     41 	char nt, na;
     42 	sequence_status *psq_stat;
     43 	track_status *ptmp;
     44 	char *lpdest;
     45 	int li, lj;
     46 
     47 	int _sequence_number;
     48 	enum MuteFlag _mflag;
     49 
     50 	_sequence_number = sequence_number;
     51 	_mflag = mflag;
     52 
     53 	if (!Is_Seq_Num_Valid(_sequence_number))
     54 	{
     55 		return;
     56 	}
     57 
     58 	/* immediate pause of sequence */
     59 	wess_disable();
     60 
     61 	/* search for all sequences with this number and turn them off */
     62 	nt = wess_driver_sequences;
     63 	na = pm_stat->seqs_active;
     64 	psq_stat = pm_stat->pseqstattbl;
     65 	if (na)
     66 	{
     67 		while (nt--)
     68 		{
     69 			if (psq_stat->flags & SEQ_ACTIVE)
     70 			{
     71 				if (psq_stat->seq_num == _sequence_number)
     72 				{
     73 					psq_stat->flags |= SEQ_PAUSE;
     74 				}
     75 				if (!--na) break;
     76 			}
     77 			psq_stat++;
     78 		}
     79 	}
     80 
     81 	queue_the_function(QUEUE_SEQ_PAUSE);
     82 	queue_the_data(&_sequence_number, sizeof(int));
     83 	queue_the_data(&_mflag, sizeof(int));
     84 
     85 	wess_enable();
     86 }
     87 
     88 void queue_wess_seq_pause(int sequence_number, enum MuteFlag mflag);
     89 
     90 void run_queue_wess_seq_pause(void) // 800317B8
     91 {
     92 	enum MuteFlag mflag;
     93 	int sequence_number;
     94 
     95 	unqueue_the_data(&sequence_number, sizeof(int));
     96 	unqueue_the_data(&mflag, sizeof(int));
     97 	queue_wess_seq_pause(sequence_number, mflag);
     98 }
     99 
    100 void queue_wess_seq_pause(int sequence_number, enum MuteFlag mflag) // 800317F8
    101 {
    102 	char nt, na;
    103 	sequence_status *psq_stat;
    104 	track_status *ptmp;
    105 	char *lpdest;
    106 	int li, lj;
    107 
    108 	int _sequence_number;
    109 	enum MuteFlag _mflag;
    110 
    111 	_sequence_number = sequence_number;
    112 	_mflag = mflag;
    113 
    114 	if (!Is_Seq_Num_Valid(_sequence_number))
    115 	{
    116 		return;
    117 	}
    118 
    119 	/* immediate pause of sequence */
    120 	wess_disable();
    121 
    122 	/* search for all sequences with this number and turn them off */
    123 	nt = wess_driver_sequences;
    124 	na = pm_stat->seqs_active;
    125 	psq_stat = pm_stat->pseqstattbl;
    126 	if (na)
    127 	{
    128 		while (nt--)
    129 		{
    130 			if (psq_stat->flags & SEQ_ACTIVE)
    131 			{
    132 				if (psq_stat->seq_num == _sequence_number)
    133 				{
    134 					if (psq_stat->flags & SEQ_PAUSE)
    135 					{
    136 						psq_stat->flags &= ~SEQ_PAUSE;
    137 
    138 						li = psq_stat->tracks_active;
    139 						lj = pm_stat->max_trks_perseq;
    140 						/* *lpdest refers to an active track if not 0xFF */
    141 						lpdest = psq_stat->ptrk_indxs;
    142 						while (lj--)
    143 						{
    144 							if (*lpdest != 0xFF)
    145 							{
    146 								ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    147 								trackstop(ptmp, psq_stat);
    148 								if (_mflag == YesMute)
    149 								{
    150 									CmdFuncArr[ptmp->patchtype][TrkMute](ptmp);
    151 								}
    152 								if (!--li) break;
    153 							}
    154 							lpdest++;
    155 						}
    156 					}
    157 				}
    158 				if (!--na) break;
    159 			}
    160 			psq_stat++;
    161 		}
    162 	}
    163 
    164 	wess_enable();
    165 }
    166 
    167 void wess_seq_restart(int sequence_number) // 800319C4
    168 {
    169 	char nt, na;
    170 	sequence_status *psq_stat;
    171 	track_status *ptmp;
    172 	char *lpdest;
    173 	int li, lj;
    174 
    175 	int _sequence_number;
    176 
    177 	_sequence_number = sequence_number;
    178 
    179 	if (!Is_Seq_Num_Valid(_sequence_number))
    180 	{
    181 		return;
    182 	}
    183 
    184 	/* immediate restart of sequence */
    185 	wess_disable();
    186 
    187 	/* search for all sequences with this number and turn them off */
    188 	nt = wess_driver_sequences;
    189 	na = pm_stat->seqs_active;
    190 	psq_stat = pm_stat->pseqstattbl;
    191 	if (na)
    192 	{
    193 		while (nt--)
    194 		{
    195 			if (psq_stat->flags & SEQ_ACTIVE)
    196 			{
    197 				if (psq_stat->seq_num == _sequence_number)
    198 				{
    199 					psq_stat->flags |= SEQ_RESTART;
    200 				}
    201 				if (!--na) break;
    202 			}
    203 			psq_stat++;
    204 		}
    205 	}
    206 
    207 	queue_the_function(QUEUE_SEQ_RESTART);
    208 	queue_the_data(&_sequence_number, sizeof(int));
    209 
    210 	wess_enable();
    211 }
    212 
    213 void queue_wess_seq_restart(int sequence_number);
    214 
    215 void run_queue_wess_seq_restart(void) // 80031A7C
    216 {
    217 	int sequence_number;
    218 
    219 	unqueue_the_data(&sequence_number, sizeof(int));
    220 	queue_wess_seq_restart(sequence_number);
    221 }
    222 
    223 void queue_wess_seq_restart(int sequence_number) // 80031AAC
    224 {
    225 	char nt, na;
    226 	sequence_status *psq_stat;
    227 	track_status *ptmp;
    228 	char *lpdest;
    229 	int li, lj;
    230 
    231 	int _sequence_number;
    232 
    233 	_sequence_number = sequence_number;
    234 
    235 	if (!Is_Seq_Num_Valid(_sequence_number))
    236 	{
    237 		return;
    238 	}
    239 
    240 	/* immediate restart of sequence */
    241 	wess_disable();
    242 
    243 	/* search for all sequences with this number and turn them off */
    244 	nt = wess_driver_sequences;
    245 	na = pm_stat->seqs_active;
    246 	psq_stat = pm_stat->pseqstattbl;
    247 	if (na)
    248 	{
    249 		while (nt--)
    250 		{
    251 			if (psq_stat->flags & SEQ_ACTIVE)
    252 			{
    253 				if (psq_stat->seq_num == _sequence_number)
    254 				{
    255 					if (psq_stat->flags & SEQ_RESTART)
    256 					{
    257 						psq_stat->flags &= ~SEQ_RESTART;
    258 						li = psq_stat->tracks_active;
    259 						lj = pm_stat->max_trks_perseq;
    260 						/* *lpdest refers to an active track if not 0xFF */
    261 						lpdest = psq_stat->ptrk_indxs;
    262 						while (lj--)
    263 						{
    264 							if (*lpdest != 0xFF)
    265 							{
    266 								ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    267 								trackstart(ptmp, psq_stat);
    268 								if (!--li) break;
    269 							}
    270 							lpdest++;
    271 						}
    272 					}
    273 				}
    274 				if (!--na) break;
    275 			}
    276 			psq_stat++;
    277 		}
    278 	}
    279 
    280 	wess_enable();
    281 }
    282 
    283 void wess_seq_pauseall(enum MuteFlag mflag, int remember) // 80031C14
    284 {
    285 	char nt, na;
    286 	sequence_status *psq_stat;
    287 	track_status *ptmp;
    288 	char *lpdest;
    289 	int li, lj;
    290 
    291 	enum MuteFlag _mflag;
    292 	int _remember;
    293 
    294 	_mflag = mflag;
    295 	_remember = remember;
    296 
    297 	if (!Is_Module_Loaded())
    298 	{
    299 		return;
    300 	}
    301 
    302 	/* immediate pause of all sequences */
    303 	wess_disable();
    304 
    305 	/* search for all sequences with this number and turn them off */
    306 	nt = wess_driver_sequences;
    307 	na = pm_stat->seqs_active;
    308 	psq_stat = pm_stat->pseqstattbl;
    309 	if (na)
    310 	{
    311 		while (nt--)
    312 		{
    313 			if (psq_stat->flags & SEQ_ACTIVE)
    314 			{
    315 				psq_stat->flags |= SEQ_PAUSE;
    316 				if (!--na) break;
    317 			}
    318 			psq_stat++;
    319 		}
    320 	}
    321 
    322 	queue_the_function(QUEUE_SEQ_PAUSEALL);
    323 	queue_the_data(&_mflag, sizeof(int));
    324 	queue_the_data(&_remember, sizeof(int));
    325 
    326 	wess_enable();
    327 }
    328 
    329 void queue_wess_seq_pauseall(enum MuteFlag mflag, int remember);
    330 
    331 void run_queue_wess_seq_pauseall(void) // 80031CCC
    332 {
    333 	enum MuteFlag mflag;
    334 	int remember;
    335 
    336 	unqueue_the_data(&mflag, sizeof(int));
    337 	unqueue_the_data(&remember, sizeof(int));
    338 	queue_wess_seq_pauseall(mflag, remember);
    339 }
    340 
    341 void queue_wess_seq_pauseall(enum MuteFlag mflag, int remember) // 80031D0C
    342 {
    343 	char nt, na;
    344 	sequence_status *psq_stat;
    345 	track_status *ptmp;
    346 	char *lpdest;
    347 	int li, lj;
    348 
    349 	enum MuteFlag _mflag;
    350 	int _remember;
    351 
    352 	_mflag = mflag;
    353 	_remember = remember;
    354 
    355 	if (!Is_Module_Loaded())
    356 	{
    357 		return;
    358 	}
    359 
    360 	/* immediate pause of all sequences */
    361 	wess_disable();
    362 
    363 	if (_mflag == YesMute)
    364 	{
    365 		start_record_music_mute(_remember);
    366 	}
    367 
    368 	/* search for all sequences with this number and turn them off */
    369 	nt = wess_driver_sequences;
    370 	na = pm_stat->seqs_active;
    371 	psq_stat = pm_stat->pseqstattbl;
    372 	if (na)
    373 	{
    374 		while (nt--)
    375 		{
    376 			if (psq_stat->flags & SEQ_ACTIVE)
    377 			{
    378 				if (psq_stat->flags & SEQ_PAUSE)
    379 				{
    380 					psq_stat->flags &= ~SEQ_PAUSE;
    381 
    382 					li = psq_stat->tracks_active;
    383 					lj = pm_stat->max_trks_perseq;
    384 					/* *lpdest refers to an active track if not 0xFF */
    385 					lpdest = psq_stat->ptrk_indxs;
    386 					while (lj--)
    387 					{
    388 						if (*lpdest != 0xFF)
    389 						{
    390 							ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    391 							trackstop(ptmp, psq_stat);
    392 							if (_mflag == YesMute)
    393 							{
    394 								CmdFuncArr[ptmp->patchtype][TrkMute](ptmp);
    395 							}
    396 							if (!--li) break;
    397 						}
    398 						lpdest++;
    399 					}
    400 
    401 					if (!--na) break;
    402 				}
    403 			}
    404 			psq_stat++;
    405 		}
    406 	}
    407 
    408 	if (_mflag == YesMute)
    409 	{
    410 		end_record_music_mute();
    411 	}
    412 
    413 	wess_enable();
    414 }
    415 
    416 void wess_seq_restartall(enum VoiceRestartFlag restart_remembered_voices) // 80031EF4
    417 {
    418 	char nt, na;
    419 	sequence_status *psq_stat;
    420 	track_status *ptmp;
    421 	char *lpdest;
    422 	int li, lj, ncnt, nc;
    423 
    424 	enum VoiceRestartFlag _restart_remembered_voices;
    425 
    426 	_restart_remembered_voices = restart_remembered_voices;
    427 
    428 	if (!Is_Module_Loaded())
    429 	{
    430 		return;
    431 	}
    432 
    433 	/* immediate restart of all sequences */
    434 	wess_disable();
    435 
    436 	/* search for all sequences with this number and turn them off */
    437 	nt = wess_driver_sequences;
    438 	na = pm_stat->seqs_active;
    439 	psq_stat = pm_stat->pseqstattbl;
    440 	if (na)
    441 	{
    442 		while (nt--)
    443 		{
    444 			if (psq_stat->flags & SEQ_ACTIVE)
    445 			{
    446 				psq_stat->flags |= SEQ_RESTART;
    447 				if (!--na) break;
    448 			}
    449 			psq_stat++;
    450 		}
    451 	}
    452 
    453 	queue_the_function(QUEUE_SEQ_RESTARTALL);
    454 	queue_the_data(&_restart_remembered_voices, sizeof(int));
    455 
    456 	wess_enable();
    457 }
    458 
    459 void queue_wess_seq_restartall(enum VoiceRestartFlag restart_remembered_voices);
    460 
    461 void run_queue_wess_seq_restartall(void) // 80031F9C
    462 {
    463 	enum VoiceRestartFlag restart_remembered_voices;
    464 
    465 	unqueue_the_data(&restart_remembered_voices, sizeof(int));
    466 	queue_wess_seq_restartall(restart_remembered_voices);
    467 }
    468 
    469 extern void do_record_music_unmute(int seq_num, int track, track_status *ptk_stat);
    470 
    471 void queue_wess_seq_restartall(enum VoiceRestartFlag restart_remembered_voices) // 80031FCC
    472 {
    473 	char nt, na;
    474 	sequence_status *psq_stat;
    475 	track_status *ptmp;
    476 	char *lpdest;
    477 	int li, lj, ncnt, nc;
    478 
    479 	enum VoiceRestartFlag _restart_remembered_voices;
    480 
    481 	_restart_remembered_voices = restart_remembered_voices;
    482 
    483 	if (!Is_Module_Loaded())
    484 	{
    485 		return;
    486 	}
    487 
    488 	/* immediate restart of all sequences */
    489 	wess_disable();
    490 
    491 	/* search for all sequences with this number and turn them off */
    492 	nt = wess_driver_sequences;
    493 	na = pm_stat->seqs_active;
    494 	psq_stat = pm_stat->pseqstattbl;
    495 	if (na)
    496 	{
    497 		while (nt--)
    498 		{
    499 			if (psq_stat->flags & SEQ_ACTIVE)
    500 			{
    501 				if (psq_stat->flags & SEQ_RESTART)
    502 				{
    503 					psq_stat->flags &= ~SEQ_RESTART;
    504 
    505 					li = psq_stat->tracks_active;
    506 					lj = pm_stat->max_trks_perseq;
    507 					/* *lpdest refers to an active track if not 0xFF */
    508 					lpdest = psq_stat->ptrk_indxs;
    509 					while (lj--)
    510 					{
    511 						if (*lpdest != 0xFF)
    512 						{
    513 							ptmp = (pm_stat->ptrkstattbl + (*lpdest));
    514 							trackstart(ptmp, psq_stat);
    515 
    516 							if (_restart_remembered_voices)
    517 							{
    518 								do_record_music_unmute(psq_stat->seq_num, *lpdest, ptmp);
    519 							}
    520 
    521 							if (!--li) break;
    522 						}
    523 						lpdest++;
    524 					}
    525 
    526 					if (!--na) break;
    527 				}
    528 			}
    529 			psq_stat++;
    530 		}
    531 	}
    532 
    533 	wess_enable();
    534 }
    535 #endif