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