workbench/devs/audio/audio_commands.c

   1 /*
   2      Copyright 2010, The AROS Development Team. All rights reserved.
   3      $Id$
   4  */
   5
   6 /*
   7  * audio.device
   8  *
   9  * by Nexus Development 2003
  10  * coded by Emanuele Cesaroni
  11  *
  12  * $Id$
  13  */
  14
  15 #include "audio_intern.h"
  16 #define DEBUG 0
  17 #include <aros/debug.h>
  18 #include <graphics/gfxbase.h>
  19
  20 /*
  21  * In CMD_WRITE when more than one bit is set is considered the lowest this keep fastly it.
  22  */
  23 BYTE writechn[] =
  24 { 0, // 0000 - 0 // This combination is bad.
  25         0, // 0001 - 1
  26         1, // 0010 - 2
  27         0, // 0011 - 3
  28         2, // 0100 - 4
  29         0, // 0101 - 5
  30         1, // 0110 - 6
  31         0, // 0111 - 7
  32         3, // 1000 - 8
  33         0, // 1001 - 9
  34         1, // 1010 - 10
  35         0, // 1011 - 11
  36         2, // 1100 - 12
  37         0, // 1101 - 13
  38         1, // 1110 - 14
  39         0 // 1111 - 15
  40         };
  41
  42 VOID setup_Units(UBYTE combination, WORD key, BYTE pri, ETASK *eta)
  43 {
  44     // se sono locked
  45     if (combination & (1 << 0))
  46     {
  47         ResetUnit(eta->et_units[0]);
  48         eta->et_units[0]->eu_allockey = key;
  49         eta->et_units[0]->eu_pri = pri;
  50         D(bug("NEWD: Setupped unit %d\n", 0));
  51     }
  52
  53     if (combination & (1 << 1))
  54     {
  55         ResetUnit(eta->et_units[1]);
  56         eta->et_units[1]->eu_allockey = key;
  57         eta->et_units[1]->eu_pri = pri;
  58         D(bug("NEWD: Setupped unit %d\n", 1));
  59     }
  60
  61     if (combination & (1 << 2))
  62     {
  63         ResetUnit(eta->et_units[2]);
  64         eta->et_units[2]->eu_allockey = key;
  65         eta->et_units[2]->eu_pri = pri;
  66         D(bug("NEWD: Setupped unit %d\n", 2));
  67     }
  68
  69     if (combination & (1 << 3))
  70     {
  71         ResetUnit(eta->et_units[3]);
  72         eta->et_units[3]->eu_allockey = key;
  73         eta->et_units[3]->eu_pri = pri;
  74         D(bug("NEWD: Setupped unit %d\n", 3));
  75     }
  76
  77     eta->et_unitmask = combination;
  78 }
  79
  80 VOID AllocateProc(struct IOAudio *audioio, ETASK *eta)
  81 {
  82     BYTE *data, len, actual, pri;
  83     WORD key;
  84     BOOL result = 0;
  85
  86     D(bug("NEWD: Arrived ADCMD_ALLOCATE from IOAudio(%x),len=%d,data=%x,key=%d,pri=%d\n",
  87           audioio, audioio->ioa_Length, audioio->ioa_Data, audioio->ioa_AllocKey,
  88           audioio->ioa_Request.io_Message.mn_Node.ln_Pri));
  89
  90     data = audioio->ioa_Data;
  91     pri = audioio->ioa_Request.io_Message.mn_Node.ln_Pri;
  92
  93     if ((!(key = audioio->ioa_AllocKey)))
  94     {
  95         key = eta->et_key++; /* Always a new key please. */
  96     }
  97
  98     if ((len = (audioio->ioa_Length & 15))) /* If len is > 0 otherwise is ok so returns unit = 0. */
  99     {
 100         ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 101         // First control search a combination which doesn't subtract any other just allocated.
 102
 103         do
 104         {
 105             if ((actual = *data++)) /* Actual combination. */
 106             {
 107                 D(bug("NEWD: combination %d\n", actual));
 108                 if ((actual & eta->et_unitmask) == 0)
 109                 {
 110                     D(bug("NEWD: after combination %d\n", actual));
 111                     setup_Units(actual, key, pri, eta);
 112                     audioio->ioa_Request.io_Unit
 113                             = (struct Unit*) ((IPTR) actual);
 114                     audioio->ioa_Request.io_Error = IONOERROR;
 115                     audioio->ioa_AllocKey = key;
 116
 117                     return; /* EXIT. */
 118                 }
 119             }
 120             else
 121             {
 122                 audioio->ioa_Request.io_Unit = (struct Unit*) NULL; /* Lenght is zero but a key is generated, unit is 0 and noerror. */
 123                 audioio->ioa_Request.io_Error = IONOERROR;
 124                 audioio->ioa_AllocKey = key;
 125
 126                 D(bug("NEWD: ADCMD_ALLOCATE asked combination 0\n"));
 127
 128                 return;
 129             }
 130         } while (--len);
 131         /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 132         // Nothing... Try now to subtract other channels with lower pri.
 133
 134         D(bug("NEWD: I try to subtract\n"));
 135
 136         data = audioio->ioa_Data;
 137         len = (audioio->ioa_Length & 15);
 138
 139         do /* First control search a combination which subtracts a combination with lower pri. */
 140         {
 141             actual = *data++; /* Actual combination. */
 142
 143             while (1)
 144             {
 145                 if ((actual & (1 << 0)) && (eta->et_unitmask & (1 << 0)))
 146                 {
 147                     if (eta->et_units[0]->eu_pri >= pri)
 148                         break;
 149                 }
 150
 151                 if ((actual & (1 << 1)) && (eta->et_unitmask & (1 << 1)))
 152                 {
 153                     if (eta->et_units[1]->eu_pri >= pri)
 154                         break;
 155                 }
 156
 157                 if ((actual & (1 << 2)) && (eta->et_unitmask & (1 << 2)))
 158                 {
 159                     if (eta->et_units[2]->eu_pri >= pri)
 160                         break;
 161                 }
 162                 if ((actual & (1 << 3)) && (eta->et_unitmask & (1 << 3)))
 163                 {
 164                     if (eta->et_units[3]->eu_pri >= pri)
 165                         break;
 166                 }
 167
 168                 result = 1;
 169                 break;
 170             }
 171
 172             if (result)
 173             {
 174                 /*
 175                  Devi semplicemente per i canali sottratti abortire le richieste di CMD_WRITE che giungevano dai task di
 176                  quelle unit� pagina 126, mettendo in error IOERR_ABORTED. Quelle in esecuzione invece vengono interrotte, quella
 177                  cached anche ma non viene messo niente in error.
 178                  */
 179
 180                 setup_Units(actual, key, pri, eta);
 181                 audioio->ioa_Request.io_Unit = (struct Unit*) ((IPTR) actual);
 182                 audioio->ioa_Request.io_Error = IONOERROR;
 183                 audioio->ioa_AllocKey = key;
 184
 185                 return;
 186             }
 187         } while (--len);
 188
 189         //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 190         // Ok, nothing to do, so or exit or put the IOAudio in waiting state.
 191
 192         if (audioio->ioa_Request.io_Flags & ADIOF_NOWAIT)
 193         {
 194             audioio->ioa_Request.io_Unit = (struct Unit*) NULL;
 195             audioio->ioa_Request.io_Error = ADIOERR_ALLOCFAILED;
 196             D(bug("NEWD: I try to subtract\n"));
 197
 198             return;
 199         }
 200         else
 201         {
 202             AddTail(&eta->et_allocatelist,
 203                     &audioio->ioa_Request.io_Message.mn_Node); /* This now in waiting state */
 204             eta->et_allocated++; /* Increase the counter please. */
 205             audioio->ioa_Request.io_Flags &= ~IOF_QUICK; /* Try this later. */
 206             audioio->ioa_Request.io_Error = ADIOERR_ALLOCFAILED;
 207             D(bug("NEWD: ADCMD_ALLOCATE put in waiting allocate list IOAudio '%x'\n",
 208                   audioio));
 209
 210             return;
 211         }
 212         //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 213     }
 214
 215     audioio->ioa_Request.io_Unit = (struct Unit*) NULL; // Lenght is zero but a key is generated, unit is 0 and noerror.
 216     audioio->ioa_Request.io_Error = IONOERROR;
 217     audioio->ioa_AllocKey = key;
 218     D(bug("NEWD: Arrived ADCMD_ALLOCATE with ioa_lenght == 0 IOAudio (%x)\n",
 219             audioio));
 220 }
 221
 222 /*
 223  * _ADCMD_ALLOCATE
 224  *
 225  * If the IOAudio can't be processed put the request at the end of the et_allocatelist.
 226  *
 227  * TODO
 228  * - What to do when the lenght is > 15 ? Actually this condition is not present because the lenght is anded with 15.
 229  * - Do the procedure of removing the cmd_writes when channels are stolens.
 230  * - Do the part of reput the request in a list in which must stay waiting for reallocs.
 231  * - Pay attention if abortio aborts an ADCMD_ALLOCATE it is removed and the counter of alloc waiting is wrong.
 232  *
 233  */
 234
 235 VOID _ADCMD_ALLOCATE(struct IOAudio *audioio, ETASK *eta)
 236 {
 237     AllocateProc(audioio, eta);
 238     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, STOLEN_SIG);
 239 }
 240
 241 /*
 242  *
 243  *  UnitCopyData
 244  * --------------
 245  *
 246  * Copies the data from the audio to the unit fields. This is a pre-cached system as the original audio.device used to do.
 247  *
 248  */
 249
 250 VOID UnitCopyData(EUNIT *unit, struct IOAudio *audioio)
 251 {
 252     ULONG period;
 253     if (audioio->ioa_Length > 131072)
 254     {
 255         unit->eu_len = 131072;
 256     }
 257     else
 258     {
 259         if (audioio->ioa_Length < 2)
 260         {
 261             unit->eu_len = 2;
 262         }
 263         else
 264         {
 265             unit->eu_len = audioio->ioa_Length;
 266         }
 267     }
 268
 269     if ((period = audioio->ioa_Period) < 124)
 270         period = 124;
 271
 272     unit->eu_data = audioio->ioa_Data;
 273     unit->eu_cycles = audioio->ioa_Cycles;
 274
 275     if (audioio->ioa_Request.io_Flags & ADIOF_PERVOL)
 276     {
 277         unit->eu_volume = audioio->ioa_Volume * 1024;
 278         //unit->eu_freq = unit->eu_clock / ((ULONG) audioio->ioa_Period);
 279         unit->eu_freq = unit->eu_clock / period;
 280     }
 281
 282     unit->eu_audioio = audioio;
 283     //audioio->ioa_Request.io_Flags &= ~IOF_QUICK; // This will be outputted surely so treat it as async.
 284
 285 }
 286
 287 /*
 288  *
 289  *  UnitAHIPerVol
 290  * ---------------
 291  *
 292  * Do the necessary procedures to change on the fly period and volume into an unit.
 293  *
 294  */
 295
 296 VOID UnitAHIPerVol(EUNIT *unit, struct IOAudio *audioio)
 297 {
 298     unit->eu_freq = unit->eu_clock / ((ULONG) audioio->ioa_Period);
 299     unit->eu_volume = audioio->ioa_Volume * 1024;
 300 }
 301
 302 /*
 303  *  UnitInitAhi
 304  * -------------
 305  *
 306  * Inits ahi and play the sample.
 307  * It removes the data from the precached place as the original audio.device used to do.
 308  *
 309  */
 310
 311 VOID UnitInitAhi(EUNIT *unit)
 312 {
 313     if (!unit->eu_usingme)
 314     {
 315         unit->eu_ahireq.ahir_Std.io_Data = unit->eu_data;
 316         unit->eu_ahireq.ahir_Std.io_Length = unit->eu_len;
 317         unit->eu_ahireq.ahir_Frequency = unit->eu_freq;
 318         unit->eu_ahireq.ahir_Volume = unit->eu_volume;
 319         unit->eu_usingme = unit->eu_audioio;
 320         unit->eu_audioio = NULL;
 321         unit->eu_savecycles = unit->eu_cycles; // The save value.
 322         unit->eu_actcycles = unit->eu_cycles; // The actual counter.
 323
 324         if (unit->eu_savecycles != 1) // Save the values for infinite repeating...
 325         {
 326             unit->eu_repdata = unit->eu_data;
 327             unit->eu_replen = unit->eu_len;
 328             unit->eu_repfreq = unit->eu_freq;
 329             unit->eu_repvolume = unit->eu_volume;
 330         }
 331
 332         BeginIO((struct IORequest *) &unit->eu_ahireq);
 333
 334         if (unit->eu_usingme->ioa_Request.io_Flags & ADIOF_WRITEMESSAGE)
 335         {
 336             D(bug("NEWD: Reply WRITE_MESSAGE from IOAudio (%x)\n",
 337                     unit->eu_usingme));
 338             ReplyMsg(&unit->eu_usingme->ioa_WriteMsg);
 339         }
 340     }
 341 }
 342
 343 /*
 344  *  UnitInitRepAhi
 345  * ----------------
 346  *
 347  * This is used to reinit ahi when we are under infinite cycles.
 348  */
 349
 350 VOID UnitInitRepAhi(EUNIT *unit)
 351 {
 352     unit->eu_ahireq.ahir_Std.io_Data = unit->eu_repdata;
 353     unit->eu_ahireq.ahir_Std.io_Length = unit->eu_replen;
 354     unit->eu_ahireq.ahir_Frequency = unit->eu_repfreq;
 355     unit->eu_ahireq.ahir_Volume = unit->eu_repvolume;
 356     BeginIO((struct IORequest *) &unit->eu_ahireq);
 357 }
 358
 359 /*
 360  *  FlushUnit
 361  * -----------
 362  *
 363  * Flushes an eaudio.device unit. So:
 364  * 1) Aborts the running audio wave.
 365  * 2) Get all the CMD_WRITE in list waiting repling them to their task with IOERR_ABORTED.
 366  * 3) Returns all the waitcycles in waitcyclelist with IOERR_ABORTED.
 367  *
 368  * ?? The running IOAudio must be replied??
 369  *
 370  */
 371
 372 VOID FlushUnit(EUNIT *unit)
 373 {
 374     struct IOAudio *audioio;
 375
 376     if (!(CheckIO((struct IORequest *) &unit->eu_ahireq))) // I stop if exists the running audio output.
 377     {
 378         AbortIO((struct IORequest *) &unit->eu_ahireq);
 379         WaitIO((struct IORequest *) &unit->eu_ahireq);
 380
 381         D(bug("NEWD: FlushUnit(): The audio in port (%d) was running now is stopped\n",
 382                 unit->eu_id));
 383     }
 384
 385     unit->eu_usingme = NULL;
 386
 387     while ((audioio = (struct IOAudio*) GetMsg(unit->eu_port))) // Now removes all the CMD_WRITE present in the list.
 388     {
 389         audioio->ioa_Request.io_Error = IOERR_ABORTED;
 390         ReplyMsg(&audioio->ioa_Request.io_Message);
 391
 392         D(bug("NEWD: FlushUnit(): Removed from the list of port (%d) the CMD_WRITE request (%x).\n",
 393             unit->eu_id, audioio));
 394     }
 395
 396     while ((audioio = (struct IOAudio*) RemHead(&unit->eu_waitcyclelist))) // Removes all the ADCMD_WAITCYCLES for this unit.
 397     {
 398         D(bug("NEWD: FlushUnit(): Found IOAuido (%x) in waitcyclelist, now i reply it with IOERR_ABORTED.\n",
 399             audioio));
 400
 401         audioio->ioa_Request.io_Error = IOERR_ABORTED;
 402         ReplyMsg(&audioio->ioa_Request.io_Message);
 403     }
 404 }
 405
 406 /*
 407  *
 408  * _CMD_RESET
 409  *
 410  */
 411
 412 VOID _CMD_RESET(struct IOAudio *audioio, ETASK *eta)
 413 {
 414     BYTE unit, chan, final = 0;
 415     EUNIT *channel;
 416     UBYTE error = IONOERROR;
 417
 418     D(bug("NEWD: Arrived CMD_RESET from IOAudio (%x), unit(%d)\n", audioio,
 419             audioio->ioa_Request.io_Unit));
 420
 421     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
 422     {
 423         do
 424         {
 425             chan = writechn[unit];
 426             channel = eta->et_units[chan];
 427
 428             if (channel->eu_allockey == audioio->ioa_AllocKey)
 429             {
 430                 FlushUnit(channel);
 431                 D(bug("NEWD: CMD_FLUSH for unit (%d)\n", chan));
 432             }
 433             else
 434             {
 435                 error = ADIOERR_NOALLOCATION;
 436             }
 437
 438             unit &= ~(1 << chan);
 439             final |= 1 << chan;
 440         } while (unit);
 441     }
 442
 443     audioio->ioa_Request.io_Unit = (struct Unit*) ((IPTR) final);
 444     audioio->ioa_Request.io_Error = error;
 445     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
 446             << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
 447 }
 448
 449 /*
 450  *  ResetUnit
 451  * -----------
 452  *
 453  * Does some procedures usefull to reset the unit, Called by CMD_RESET and other.
 454  *
 455  */
 456
 457 VOID ResetUnit(EUNIT *unit)
 458 {
 459     unit->eu_audioio = NULL; /* This is sufficent to erase the pre-cache requestes. */
 460     FlushUnit(unit); /* This stops the running audio and removes all the quequed CMD_WRITE and ADCMD_WAITCYCLES. */
 461 }
 462
 463 /*
 464  *
 465  *  ReAllocateUnits
 466  * -----------------
 467  *
 468  * This block try again to ADCMD_ALLOCATE some IOAUdio request which are waiting for channels. Actually it is called from
 469  * ADCMD_FREE or ADCMD_SETPREC.
 470  *
 471  * - Pay attention to the counter of the allocate in waiting if an abortio removes it the system collapses !!!!!!!!
 472  *
 473  */
 474
 475 VOID ReAllocateUnits(ETASK *eta)
 476 {
 477     UWORD allocated;
 478     struct IOAudio *wait;
 479
 480     if ((allocated = eta->et_allocated)) // If any in list waiting for being allocated.
 481     {
 482         while ((wait = (struct IOAudio*) RemHead(&eta->et_allocatelist)))
 483         {
 484             eta->et_allocated--;
 485
 486             D(bug("NEWD: ADCMD_FREE: Trying to allocate this again. IOAudio (%x)\n", wait));
 487             AllocateProc(wait, eta);
 488
 489             if ((wait->ioa_Request.io_Flags & IOF_QUICK) == 0)
 490             {
 491                 if ((wait->ioa_Request.io_Error == ADIOERR_ALLOCFAILED)
 492                         && (wait->ioa_Request.io_Flags & ADIOF_NOWAIT))
 493                 {
 494                     ReplyMsg(&wait->ioa_Request.io_Message);
 495                 }
 496                 else if (wait->ioa_Request.io_Error == IONOERROR)
 497                 {
 498                     ReplyMsg(&wait->ioa_Request.io_Message);
 499                 }
 500             }
 501
 502             if (--allocated == 0)
 503             {
 504                 break; // Decrease the number in list and exit if empty.
 505             }
 506         }
 507     }
 508 }
 509
 510 /*
 511  * _ADCMD_FREE
 512  *
 513  * Frees some units then:
 514  * 1) See if other ADCMD_ALLOCATE are in waiting state.
 515  *
 516  */
 517
 518 VOID _ADCMD_FREE(struct IOAudio *audioio, ETASK *eta)
 519 {
 520     BYTE unit, chan, final = 0;
 521     EUNIT *channel;
 522     UBYTE error = IONOERROR;
 523
 524     D(bug("NEWD: Arrived CMD_FREE from IOAudio (%x), unit(%d)\n", audioio,
 525             audioio->ioa_Request.io_Unit));
 526
 527     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
 528     {
 529         do
 530         {
 531             chan = writechn[unit];
 532             channel = eta->et_units[chan];
 533
 534             if (channel->eu_allockey == audioio->ioa_AllocKey)
 535             {
 536                 //if(accessibili)
 537                 {
 538                     ResetUnit(channel); // Reset this one please.
 539                     eta->et_unitmask &= ~(1 << chan); // This channel is now free.
 540                     channel->eu_allockey = 0; // Not needed!
 541                     channel->eu_pri = -127; // Not needed!
 542
 543                     D(bug("NEWD: CMD_FREE freed unit (%d)\n", chan));
 544                 }
 545                 //else  error = ADIOERR_NOALLOCATION;
 546             }
 547             else
 548             {
 549                 error = ADIOERR_NOALLOCATION;
 550             }
 551
 552             unit &= ~(1 << chan);
 553             final |= 1 << chan;
 554         } while (unit);
 555     }
 556
 557     D(bug("NEWD: Now i reply CMD_FREE from IOAudio (%x), unit(%d)\n", audioio,
 558             audioio->ioa_Request.io_Unit));
 559
 560     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
 561     audioio->ioa_Request.io_Error = error;
 562
 563     //Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,STOLEN_SIG);
 564     Signal(ematsys->ts_calltask, STOLEN_SIG);
 565
 566     if (final) // Only if something now is freed touch the allocating waiting for...
 567     {
 568         ReAllocateUnits(eta);
 569         // verificare ora il discorso dei locks.
 570     }
 571
 572 }
 573
 574 /*
 575  *
 576  * _CMD_WRITE
 577  *
 578  * See again the part of bad allockkey the signal there is wrong.
 579  */
 580
 581 VOID _CMD_WRITE(struct IOAudio *audioio, ETASK *eta, EUNIT *unit)
 582 {
 583     D(bug("NEWD: Arrived CMD_WRITE from IOAudio (%x), emaunit (%d), cycles (%d), flags (%d)\n",
 584         audioio, unit->eu_id, audioio->ioa_Cycles, audioio->ioa_Request.io_Flags));
 585     D(bug("NEWD: Arrived CMD_WRITE from IOAudio (%x), period (%d), len (%d), pri (%d) key (%d)\n",
 586         audioio, audioio->ioa_Period, audioio->ioa_Length,
 587         audioio->ioa_Request.io_Message.mn_Node.ln_Pri, audioio->ioa_AllocKey));
 588     D(bug("NEWD: Arrived CMD_WRITE from IOAudio (%x), data (%d) volume (%d)\n",
 589             audioio, audioio->ioa_Data, audioio->ioa_Volume));
 590
 591     //D(bug("datalist\n",0, 0,0,0,0));
 592     //ablo = audioio->ioa_Data;
 593     //do
 594     //{
 595     //  D(bug("%d ",*ablo,0,0,0,0));
 596     //
 597     //}while((counter++) < 100);
 598     //D(bug("\n",0, 0,0,0,0));
 599
 600     if (audioio->ioa_AllocKey == unit->eu_allockey)
 601     {
 602         audioio->ioa_Request.io_Flags &= ~IOF_QUICK;
 603         AddTail(&unit->eu_writewaitlist,
 604                 &audioio->ioa_Request.io_Message.mn_Node); // Put the new one in the tail of the list.
 605         audioio = (struct IOAudio*) RemHead(&unit->eu_writewaitlist); // Pick the head.
 606
 607         if ((unit->eu_status & UNIT_STOP) == 0) // If the unit isn't stopped.
 608         {
 609             if ((unit->eu_usingme == NULL) && (unit->eu_audioio == NULL)) // Precache free, executing free.
 610             {
 611                 UnitCopyData(unit, audioio);
 612                 UnitInitAhi(unit);
 613
 614                 if ((audioio = (struct IOAudio*) RemHead(
 615                         &unit->eu_writewaitlist)))
 616                 {
 617                     UnitCopyData(unit, audioio);
 618                 }
 619
 620                 return;
 621             }
 622
 623             if ((unit->eu_usingme != NULL) && (unit->eu_audioio == NULL))
 624             {
 625                 UnitCopyData(unit, audioio);
 626                 return;
 627             }
 628
 629             if ((unit->eu_usingme == NULL) && (unit->eu_audioio != NULL))
 630             {
 631                 UnitInitAhi(unit);
 632                 UnitCopyData(unit, audioio);
 633
 634                 return;
 635             }
 636         }
 637
 638         AddHead(&unit->eu_writewaitlist,
 639                 &audioio->ioa_Request.io_Message.mn_Node); // Reput if channel is stopped or cache and running are busy.
 640
 641         return;
 642     }
 643     else
 644     {
 645         D(bug("NEWD: CMD_WRITE bad allockey or inaccessible channel, IOAudio (%x), key (%d)\n",
 646             audioio, audioio->ioa_AllocKey));
 647         audioio->ioa_Request.io_Unit = NULL;
 648         audioio->ioa_Request.io_Error = ADIOERR_NOALLOCATION;
 649
 650         Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
 651                 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
 652
 653         if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
 654         {
 655             ReplyMsg(&audioio->ioa_Request.io_Message);
 656         }
 657     }
 658 }
 659
 660 /*
 661  *  process_UnitsCmd
 662  * ------------------
 663  *
 664  * Processes all the commands which interacts with all the units.
 665  *
 666  */
 667
 668 VOID process_UnitsCmd(struct IOAudio* MyIORequest, ETASK *eta)
 669 {
 670     switch (MyIORequest->ioa_Request.io_Command)
 671     {
 672     case ADCMD_ALLOCATE:
 673         _ADCMD_ALLOCATE(MyIORequest, eta);
 674         break;
 675
 676     case ADCMD_FREE:
 677         _ADCMD_FREE(MyIORequest, eta);
 678         break;
 679
 680     case ADCMD_PERVOL:
 681         _ADCMD_PERVOL(MyIORequest, eta);
 682         break;
 683
 684     case ADCMD_SETPREC:
 685         _ADCMD_SETPREC(MyIORequest, eta);
 686         break;
 687
 688     case ADCMD_FINISH:
 689         _ADCMD_FINISH(MyIORequest, eta);
 690         break;
 691
 692     case ADCMD_WAITCYCLE:
 693         _ADCMD_WAITCYCLE(MyIORequest, eta);
 694         break;
 695
 696     case ADCMD_LOCK:
 697         _ADCMD_LOCK(MyIORequest, eta);
 698         break;
 699
 700     case CMD_FLUSH:
 701         _CMD_FLUSH(MyIORequest, eta);
 702         break;
 703
 704     case CMD_RESET:
 705         _CMD_RESET(MyIORequest, eta);
 706         break;
 707
 708     case CMD_STOP:
 709         _CMD_STOP(MyIORequest, eta);
 710         break;
 711
 712     case CMD_START:
 713         _CMD_START(MyIORequest, eta);
 714         break;
 715
 716     case CMD_UPDATE:
 717         _CMD_UPDATE(MyIORequest, eta);
 718         break;
 719
 720     case CMD_CLEAR:
 721         _CMD_CLEAR(MyIORequest, eta);
 722         break;
 723
 724     case CMD_READ:
 725         _CMD_READ(MyIORequest, eta);
 726         break;
 727
 728     case CMD_ABORTIO: // This is a my command.
 729         _CMD_ABORTIO(MyIORequest, eta);
 730         break;
 731
 732     case CMD_CLOSE: // This is a my command.
 733         _CMD_CLOSE(MyIORequest, eta);
 734         break;
 735     }
 736 }
 737
 738 /*
 739  *  free_ETask
 740  * ------------
 741  *
 742  * Frees the ETASK system, all ports, closes the device etc..
 743  *
 744  */
 745
 746 VOID free_ETask(ETASK *eta)
 747 {
 748     CloseLibrary((struct Library*) eta->et_gfxbase);
 749
 750     free_EUnit(eta, eta->et_units[3]); // Free the units.
 751     free_EUnit(eta, eta->et_units[2]);
 752     free_EUnit(eta, eta->et_units[1]);
 753     free_EUnit(eta, eta->et_units[0]);
 754
 755     if (!CheckIO((struct IORequest *) eta->et_openahireq))
 756     {
 757         AbortIO((struct IORequest *) eta->et_openahireq);
 758     }
 759
 760     CloseDevice((struct IORequest *) eta->et_openahireq);
 761     DeleteIORequest((struct IORequest *) eta->et_openahireq);
 762     DeleteMsgPort((struct MsgPort*) eta->et_portahi);
 763     DeleteMsgPort((struct MsgPort*) eta->et_portunits);
 764     DeleteMsgPort((struct MsgPort*) eta->et_portunit3);
 765     DeleteMsgPort((struct MsgPort*) eta->et_portunit2);
 766     DeleteMsgPort((struct MsgPort*) eta->et_portunit1);
 767     DeleteMsgPort((struct MsgPort*) eta->et_portunit0);
 768     enode_FreeNode((ENODE*) eta);
 769 }
 770
 771 /*
 772  *  init_ETask
 773  * ------------
 774  *
 775  * Initilizes the new style of manage the problem, so it allocs the unique task structure with 4 msgports for audio channels, 1 ports
 776  * for manage requests for every channels, 4 structs for the units.
 777  *
 778  */
 779
 780 ETASK *init_ETask( VOID)
 781 {
 782     ETASK *eta;
 783
 784     if ((eta = (ETASK *) enode_AllocNode(sizeof(ETASK),
 785             (unsigned long int) FindTask(NULL))))
 786     {
 787         eta->et_key = 1;
 788         eta->et_unitmask = 0;
 789
 790         if ((eta->et_portunit0 = (struct MsgPort*) CreateMsgPort()))
 791         {
 792             if ((eta->et_portunit1 = (struct MsgPort*) CreateMsgPort()))
 793             {
 794                 if ((eta->et_portunit2 = (struct MsgPort*) CreateMsgPort()))
 795                 {
 796                     if ((eta->et_portunit3 = (struct MsgPort*) CreateMsgPort()))
 797                     {
 798                         if ((eta->et_portunits
 799                                 = (struct MsgPort*) CreateMsgPort()))
 800                         {
 801                             if ((eta->et_portahi
 802                                     = (struct MsgPort*) CreateMsgPort()))
 803                             {
 804                                 if ((eta->et_openahireq
 805                                         = (struct AHIRequest*) CreateIORequest(
 806                                                 eta->et_portahi,
 807                                                 sizeof(struct AHIRequest))))
 808                                 {
 809                                     eta->et_openahireq->ahir_Version = 4;
 810
 811                                     if (!(OpenDevice(
 812                                             "ahi.device",
 813                                             AHI_DEFAULT_UNIT,
 814                                             (struct IORequest*) eta->et_openahireq,
 815                                             0)))
 816                                     {
 817                                         if ((eta->et_gfxbase
 818                                                 = (struct GfxBase*) OpenLibrary(
 819                                                         "graphics.library", 0L)))
 820                                         {
 821                                             if (eta->et_gfxbase->DisplayFlags
 822                                                     & PAL)
 823                                             {
 824                                                 eta->et_clock = 3546895;
 825                                             }
 826                                             else
 827                                             {
 828                                                 eta->et_clock = 3579545;
 829                                             }
 830
 831                                             if ((eta->et_units[0] = init_EUnit(
 832                                                     eta, 1 << 0,
 833                                                     eta->et_portunit0)))
 834                                             {
 835                                                 if ((eta->et_units[1]
 836                                                         = init_EUnit(
 837                                                                 eta,
 838                                                                 1 << 1,
 839                                                                 eta->et_portunit1)))
 840                                                 {
 841                                                     if ((eta->et_units[2]
 842                                                             = init_EUnit(
 843                                                                     eta,
 844                                                                     1 << 2,
 845                                                                     eta->et_portunit2)))
 846                                                     {
 847                                                         if ((eta->et_units[3]
 848                                                                 = init_EUnit(
 849                                                                         eta,
 850                                                                         1 << 3,
 851                                                                         eta->et_portunit3)))
 852                                                         {
 853                                                             eta->et_ports[0]
 854                                                                     = eta->et_portunit0;
 855                                                             eta->et_ports[1]
 856                                                                     = eta->et_portunit1;
 857                                                             eta->et_ports[2]
 858                                                                     = eta->et_portunit2;
 859                                                             eta->et_ports[3]
 860                                                                     = eta->et_portunit3;
 861                                                             NewList(
 862                                                                     &eta->et_allocatelist); // The allocating waiting for.
 863                                                             eta->et_allocated
 864                                                                     = 0; // No one in list.
 865
 866                                                             return eta;
 867
 868                                                         }
 869
 870                                                         free_EUnit(
 871                                                                 eta,
 872                                                                 eta->et_units[2]);
 873                                                     }
 874
 875                                                     free_EUnit(eta,
 876                                                             eta->et_units[1]);
 877                                                 }
 878
 879                                                 free_EUnit(eta,
 880                                                         eta->et_units[0]);
 881                                             }
 882
 883                                             CloseLibrary(
 884                                                     (struct Library*) eta->et_gfxbase);
 885                                         }
 886
 887                                         if (!(CheckIO(
 888                                                 (struct IORequest*) eta->et_openahireq)))
 889                                         {
 890                                             AbortIO(
 891                                                     (struct IORequest*) eta->et_openahireq);
 892                                         }
 893
 894                                         CloseDevice(
 895                                                 (struct IORequest*) eta->et_openahireq);
 896                                     }
 897
 898                                     DeleteIORequest(
 899                                             (struct IORequest *) eta->et_openahireq);
 900                                 }
 901
 902                                 DeleteMsgPort((struct MsgPort*) eta->et_portahi);
 903                             }
 904
 905                             DeleteMsgPort((struct MsgPort*) eta->et_portunits);
 906                         }
 907
 908                         DeleteMsgPort((struct MsgPort*) eta->et_portunit3);
 909                     }
 910
 911                     DeleteMsgPort((struct MsgPort*) eta->et_portunit2);
 912                 }
 913
 914                 DeleteMsgPort((struct MsgPort*) eta->et_portunit1);
 915             }
 916
 917             DeleteMsgPort((struct MsgPort*) eta->et_portunit0);
 918         }
 919
 920         enode_FreeNode((ENODE*) eta);
 921     }
 922
 923     return NULL;
 924 }
 925
 926 /*
 927  *
 928  *  free_EUnit
 929  * ------------
 930  *
 931  * Deletes the unit.
 932  *
 933  */
 934
 935 VOID free_EUnit(ETASK *estruct, EUNIT *unit)
 936 {
 937     D(
 938         if(IsListEmpty(&unit->eu_writewaitlist))
 939         {
 940             D(bug("NEWD: free_Unit() writewaitlist is empty (unit %d).\n", unit->eu_id));
 941         }
 942         else
 943         {
 944             D(bug("NEWD: free_Unit() writewaitlist is NOT empty (unit %d).\n", unit->eu_id));
 945         }
 946
 947         if (IsListEmpty(&unit->eu_waitcyclelist))
 948         {
 949             D(bug("NEWD: free_Unit() waitcyclelist is empty (unit %d).\n", unit->eu_id));
 950         }
 951         else
 952         {
 953             D(bug("NEWD: free_Unit() waitcyclelist is NOT empty (unit %d).\n", unit->eu_id));
 954         }
 955     );
 956
 957     if (!(CheckIO((struct IORequest *) &unit->eu_ahireq)))
 958     {
 959         AbortIO((struct IORequest *) &unit->eu_ahireq);
 960     }
 961
 962     DeleteIORequest((struct IORequest *) &unit->eu_ahireq);
 963 }
 964
 965 /*
 966  *
 967  *  init_EUnit
 968  * ------------
 969  *
 970  * Initializes the unit block. The unit is just an iorequest to interact with AHI or TIMER device.
 971  *      Returns the unit or NULL if fails.
 972  *
 973  * >Syn
 974  * *unit = InitEUnit(*etask,channel,*msgport)
 975  */
 976
 977 EUNIT *init_EUnit(ETASK *estruct, UBYTE channel, struct MsgPort *myport)
 978 {
 979     EUNIT *unit;
 980
 981     if ((unit = (EUNIT*) CreateIORequest(estruct->et_portahi, sizeof(EUNIT))))
 982     {
 983         NewList(&unit->eu_writewaitlist); // All the ones under writing.
 984         NewList(&unit->eu_waitcyclelist); // All the ones under waitcycle.
 985         unit->eu_clock = estruct->et_clock;
 986         unit->eu_id = writechn[channel];
 987         unit->eu_port = myport;
 988         unit->eu_usingme = NULL;
 989         unit->eu_audioio = NULL;
 990         unit->eu_status = 0; // Status ready.
 991         unit->eu_ahireq.ahir_Std.io_Message.mn_Node.ln_Pri = 0;
 992         unit->eu_ahireq.ahir_Std.io_Command = CMD_WRITE;
 993         unit->eu_ahireq.ahir_Std.io_Offset = 0;
 994         unit->eu_ahireq.ahir_Type = AHIST_M8S;
 995         unit->eu_ahireq.ahir_Link = NULL;
 996         unit->eu_ahireq.ahir_Std.io_Message.mn_ReplyPort = estruct->et_portahi;
 997         unit->eu_ahireq.ahir_Std.io_Device
 998                 = estruct->et_openahireq->ahir_Std.io_Device;
 999         unit->eu_ahireq.ahir_Std.io_Unit
1000                 = estruct->et_openahireq->ahir_Std.io_Unit;
1001
1002         if (channel & (1 << 1 | 1 << 2))
1003         {
1004             unit->eu_ahireq.ahir_Position = 0x10000; // right.
1005         }
1006         else
1007         {
1008             unit->eu_ahireq.ahir_Position = 0; // left.
1009         }
1010
1011         return unit;
1012     }
1013
1014     return NULL;
1015 }
1016
1017 /*
1018  *  TaskBody
1019  * ----------
1020  *
1021  * The slave process main function.
1022  */
1023
1024 VOID TaskBody( VOID)
1025 {
1026     ULONG waitsignal, signalset;
1027     struct IOAudio *ioaudioreq;
1028     ETASK *eta;
1029     EUNIT *unit;
1030     BOOL close = TRUE;
1031
1032     if ((eta = init_ETask()))
1033     {
1034         global_eta = eta;
1035         eta->et_slavetask = FindTask(NULL);
1036         ematsys->ts_initio->ioa_Request.io_Error = IONOERROR;
1037         Signal(ematsys->ts_opentask, STOLEN_SIG);
1038
1039         D(bug("NEWD: SLAVE PROCESS OPERATING.....\n"));
1040
1041         waitsignal = (1 << eta->et_portunit0->mp_SigBit) | (1
1042                 << eta->et_portunit1->mp_SigBit) | (1
1043                 << eta->et_portunit2->mp_SigBit) | (1
1044                 << eta->et_portunit3->mp_SigBit) | (1
1045                 << eta->et_portunits->mp_SigBit) | (1
1046                 << eta->et_portahi->mp_SigBit);
1047
1048         while (close)
1049         {
1050             signalset = Wait(waitsignal);
1051
1052             if (signalset & (1 << eta->et_portunit0->mp_SigBit)) // PORT 0.
1053             {
1054                 while ((ioaudioreq
1055                         = (struct IOAudio*) GetMsg(eta->et_portunit0)))
1056                 {
1057                     _CMD_WRITE(ioaudioreq, eta, eta->et_units[0]);
1058                     Signal(ioaudioreq->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1059                             STOLEN_SIG);
1060                 }
1061             }
1062             if (signalset & (1 << eta->et_portunit1->mp_SigBit)) // PORT 1.
1063             {
1064                 while ((ioaudioreq
1065                         = (struct IOAudio*) GetMsg(eta->et_portunit1)))
1066                 {
1067                     _CMD_WRITE(ioaudioreq, eta, eta->et_units[1]);
1068                     Signal(ioaudioreq->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1069                             STOLEN_SIG);
1070                 }
1071             }
1072             if (signalset & (1 << eta->et_portunit2->mp_SigBit)) // PORT 2.
1073             {
1074                 while ((ioaudioreq
1075                         = (struct IOAudio*) GetMsg(eta->et_portunit2)))
1076                 {
1077                     _CMD_WRITE(ioaudioreq, eta, eta->et_units[2]);
1078                     Signal(ioaudioreq->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1079                             STOLEN_SIG);
1080                 }
1081             }
1082             if (signalset & (1 << eta->et_portunit3->mp_SigBit)) // PORT 3.
1083             {
1084                 while ((ioaudioreq
1085                         = (struct IOAudio*) GetMsg(eta->et_portunit3)))
1086                 {
1087                     _CMD_WRITE(ioaudioreq, eta, eta->et_units[3]);
1088                     Signal(ioaudioreq->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1089                             STOLEN_SIG);
1090                 }
1091             }
1092             //--------------------------------------------------------------------------------------------------------------------------
1093             if (signalset & (1 << eta->et_portahi->mp_SigBit)) // AHI REPLY PORT.
1094             {
1095                 while ((unit = (EUNIT*) GetMsg(eta->et_portahi)))// reply the I/Os.
1096                 {
1097                     //D(bug("NEWD: this is the real ahi return unit(%d), ioreq (%d)\n",unit->eu_id, unit->eu_usingme));
1098
1099                     if ((ioaudioreq = unit->eu_usingme)) // This one is ended.
1100                     {
1101                         if (unit->eu_savecycles) // No infinite in this != 0.
1102                         {
1103                             if (--unit->eu_actcycles == 0)
1104                             {
1105                                 IPTR tmpunit =
1106                                         (IPTR) ioaudioreq->ioa_Request.io_Unit;
1107                                 tmpunit |= 1 << unit->eu_id;
1108                                 ioaudioreq->ioa_Request.io_Unit
1109                                         = (APTR) tmpunit;
1110
1111                                 ioaudioreq->ioa_Request.io_Error = IONOERROR;
1112
1113                                 ReplyMsg(&ioaudioreq->ioa_Request.io_Message);
1114
1115                                 D(
1116                                         bug(
1117                                                 "NEWD: AHI RETURNS  Unit(%d), ioreq (%d)\n",
1118                                                 unit->eu_id, ioaudioreq,
1119                                                 0));
1120
1121                                 /*
1122                                  unit->eu_usingme = NULL; // This informs that the unit now is free.
1123
1124                                  if(unit->eu_audioio)
1125                                  {
1126                                  UnitInitAhi(unit); // Ok send soon now the pre-cached.
1127                                  }
1128
1129                                  while(ioaudioreq = (struct IOAudio*)  RemHead(&unit->eu_writewaitlist))          // Examine for this unit only one request in waiting status.
1130                                  {
1131                                  D(bug("NEWD: Founded ioreq (%d) in writewaitlist, now i process it.\n",ioaudioreq,0,0,0,0));
1132
1133                                  _CMD_WRITE(ioaudioreq,eta,unit);
1134
1135                                  if(unit->eu_audioio)
1136                                  {
1137                                  break;                 // If the precached is empty you can exit.
1138                                  }
1139                                  }
1140                                  */
1141                                 unit->eu_usingme = NULL;
1142
1143                                 if (unit->eu_audioio)
1144                                 {
1145                                     UnitInitAhi(unit);
1146
1147                                     if ((ioaudioreq
1148                                             = (struct IOAudio*) RemHead(
1149                                                     &unit->eu_writewaitlist)))
1150                                     {
1151                                         UnitCopyData(unit, ioaudioreq);
1152
1153                                         D(bug("NEWD: PUT ioreq (%x) IN PRECACHE\n", ioaudioreq));
1154                                     }
1155                                 }
1156                                 else
1157                                 {
1158                                     if ((ioaudioreq
1159                                             = (struct IOAudio*) RemHead(
1160                                                     &unit->eu_writewaitlist)))
1161                                     {
1162                                         UnitCopyData(unit, ioaudioreq);
1163                                         UnitInitAhi(unit);
1164
1165                                         D(bug("NEWD: EXECUTED ioreq (%x)\n", ioaudioreq));
1166
1167                                         if ((ioaudioreq
1168                                                 = (struct IOAudio*) RemHead(
1169                                                         &unit->eu_writewaitlist)))
1170                                         {
1171                                             UnitCopyData(unit, ioaudioreq);
1172
1173                                             D(bug("NEWD: PUT ioreq (%x) IN PRECACHE\n", ioaudioreq));
1174                                         }
1175                                     }
1176                                 }
1177                             }
1178                             else
1179                             {
1180                                 UnitInitRepAhi(unit);
1181                             }
1182                         }
1183                         else // This zero infinite loop.
1184                         {
1185                             UnitInitRepAhi(unit);
1186                         }
1187
1188                         ReplyWaitCycles(unit, eta); // Reply to whom was waiting for a cycle end.
1189                     }
1190                 }
1191             }
1192             //--------------------------------------------------------------------------------------------------------------------------
1193             if (signalset & (1 << eta->et_portunits->mp_SigBit)) // ALL THE PORTS.
1194             {
1195                 while ((ioaudioreq
1196                         = (struct IOAudio*) GetMsg(eta->et_portunits)))
1197                 {
1198                     process_UnitsCmd(ioaudioreq, eta);
1199
1200                     if (ioaudioreq->ioa_Request.io_Command == CMD_CLOSE)
1201                     {
1202                         D(bug("NEWD: RECEIVED CLOSE\n"));
1203                         close = FALSE;
1204                         break;
1205                     }
1206                 }
1207             }
1208             //--------------------------------------------------------------------------------------------------------------------------
1209         }
1210     }
1211     else
1212     {
1213         ematsys->ts_initio->ioa_Request.io_Error = IOERR_OPENFAIL; // Wrong! Inform my father...
1214         Signal(ematsys->ts_initio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1215                 1 << ematsys->ts_initio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1216     }
1217 }
1218
1219 VOID UnitReWrite(EUNIT *unit)
1220 {
1221     struct IOAudio *ioaudioreq;
1222
1223     if ((unit->eu_audioio != NULL) && (unit->eu_usingme == NULL))
1224     {
1225         UnitInitAhi(unit);
1226
1227         D(bug("NEWD: Cache presente ho initializzato unit %d\n", unit->eu_id));
1228
1229         if ((ioaudioreq = (struct IOAudio*) RemHead(&unit->eu_writewaitlist)))
1230         {
1231             UnitCopyData(unit, ioaudioreq);
1232         }
1233     }
1234     else if ((unit->eu_audioio == NULL) && (unit->eu_usingme != NULL))
1235     {
1236         D(bug("NEWD: Cache nulla ma ioreq in function %d\n", unit->eu_id));
1237
1238         if ((ioaudioreq = (struct IOAudio*) RemHead(&unit->eu_writewaitlist)))
1239         {
1240             UnitCopyData(unit, ioaudioreq);
1241         }
1242
1243     }
1244     else if ((unit->eu_audioio == NULL) && (unit->eu_usingme == NULL))
1245     {
1246         D(bug("NEWD: Tutto vuoto provo l'init in unit %d\n", unit->eu_id));
1247
1248         if ((ioaudioreq = (struct IOAudio*) RemHead(&unit->eu_writewaitlist)))
1249         {
1250             D(bug("NEWD: Tutto vuoto ma c' per l'init %d\n", unit->eu_id));
1251
1252             UnitCopyData(unit, ioaudioreq);
1253             UnitInitAhi(unit);
1254         }
1255
1256         if ((ioaudioreq = (struct IOAudio*) RemHead(&unit->eu_writewaitlist)))
1257         {
1258             D(bug("NEWD: Tutto vuoto e anche per il cache %d\n", unit->eu_id));
1259             UnitCopyData(unit, ioaudioreq);
1260         }
1261     }
1262 }
1263
1264 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1265 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1266 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1267
1268
1269 /*
1270  *
1271  * _ADCMD_LOCK
1272  *
1273  * - This must be ended!!!!!!!
1274  *
1275  */
1276
1277 VOID _ADCMD_LOCK(struct IOAudio *audioio, ETASK *eta)
1278 {
1279     BYTE unit, chan, final = 0;
1280     EUNIT *channel;
1281     UBYTE error = IONOERROR;
1282
1283     D(bug("NEWD: Arrived ADCMD_LOCK from IOAudio (%x), unit(%d)\n", audioio,
1284             audioio->ioa_Request.io_Unit));
1285
1286     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
1287     {
1288         do
1289         {
1290             chan = writechn[unit]; // Get the lowest channel.
1291             channel = eta->et_units[chan];
1292
1293             if (channel->eu_allockey == audioio->ioa_AllocKey)
1294             {
1295                 final |= 1 << chan; // Ok for this unit the command is successfull.
1296
1297                 // ????????????????????????????????????????????????
1298
1299             }
1300             else
1301             {
1302                 error = ADIOERR_NOALLOCATION;
1303             }
1304
1305             unit &= ~(1 << chan);
1306         } while (unit);
1307     }
1308     else
1309     {
1310         error = ADIOERR_NOALLOCATION;
1311     }
1312
1313     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
1314     audioio->ioa_Request.io_Error = error;
1315     Signal(ematsys->ts_calltask, STOLEN_SIG);
1316 }
1317
1318 /*
1319  *
1320  * ADCMD_LOCK
1321  *
1322  */
1323
1324 void audio_LOCK(struct IOAudio *audioio)
1325 {
1326     ULONG oldsignals;
1327
1328     ematsys->ts_calltask = FindTask(NULL);
1329     oldsignals = SetSignal(0, STOLEN_SIG);
1330
1331     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1332     Wait(STOLEN_SIG);
1333     SetSignal(oldsignals, STOLEN_SIG);
1334
1335     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1336     {
1337         ReplyMsg(&audioio->ioa_Request.io_Message);
1338     }
1339 }
1340
1341 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1342
1343 /*
1344  *
1345  * _ADCMD_FINISH
1346  *
1347  * - This must be ended!!!!!!!
1348  *
1349  */
1350
1351 VOID _ADCMD_FINISH(struct IOAudio *audioio, ETASK *eta)
1352 {
1353     BYTE unit, chan, final = 0;
1354     EUNIT *channel;
1355     UBYTE error = IONOERROR;
1356
1357     D(bug("NEWD: Arrived ADCMD_FINISH from IOAudio (%x), unit(%d)\n", audioio,
1358             audioio->ioa_Request.io_Unit));
1359
1360     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
1361     {
1362         do
1363         {
1364             chan = writechn[unit]; // Get the lowest channel.
1365             channel = eta->et_units[chan];
1366
1367             if (channel->eu_allockey == audioio->ioa_AllocKey)
1368             {
1369                 final |= 1 << chan; // Ok for this unit the command is successfull.
1370
1371                 // ????????????????????????????????????????????????
1372
1373             }
1374             else
1375                 error = ADIOERR_NOALLOCATION;
1376             unit &= ~(1 << chan);
1377         } while (unit);
1378     }
1379     else
1380     {
1381         error = ADIOERR_NOALLOCATION;
1382     }
1383
1384     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
1385     audioio->ioa_Request.io_Error = error;
1386     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
1387             << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1388 }
1389
1390 /*
1391  *
1392  * ADCMD_FINISH
1393  *
1394  */
1395
1396 void audio_FINISH(struct IOAudio *audioio)
1397 {
1398     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1399     Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1400
1401     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1402     {
1403         ReplyMsg(&audioio->ioa_Request.io_Message);
1404     }
1405 }
1406
1407 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1408
1409
1410 /*
1411  *
1412  * _ADCMD_PERVOL
1413  *
1414  */
1415
1416 VOID _ADCMD_PERVOL(struct IOAudio *audioio, ETASK *eta)
1417 {
1418     BYTE unit, chan, final = 0;
1419     EUNIT *channel;
1420     UBYTE error = IONOERROR;
1421
1422     D(bug("NEWD: Arrived ADCMD_PERVOL from IOAudio (%x), unit(%d)\n", audioio,
1423             audioio->ioa_Request.io_Unit));
1424
1425     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
1426     {
1427         do
1428         {
1429             chan = writechn[unit]; // Get the lowest channel.
1430             channel = eta->et_units[chan];
1431             if (channel->eu_allockey == audioio->ioa_AllocKey)
1432             {
1433                 final |= 1 << chan; // Ok for this unit the command is successfull.
1434                 UnitAHIPerVol(channel, audioio);
1435             }
1436             else
1437             {
1438                 error = ADIOERR_NOALLOCATION;
1439             }
1440
1441             unit &= ~(1 << chan);
1442         } while (unit);
1443     }
1444     else
1445     {
1446         error = ADIOERR_NOALLOCATION;
1447     }
1448
1449     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
1450     audioio->ioa_Request.io_Error = error;
1451     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, STOLEN_SIG);
1452 }
1453
1454 /*
1455  *
1456  * ADCMD_PERVOL
1457  *
1458  * this shoul work
1459  */
1460
1461 void audio_PERVOL(struct IOAudio *audioio)
1462 {
1463     struct Task *oldtask;
1464     ULONG oldsignals;
1465
1466     oldtask = audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask;
1467     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = FindTask(NULL);
1468     oldsignals = SetSignal(0, STOLEN_SIG);
1469
1470     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1471     Wait(STOLEN_SIG);
1472
1473     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = oldtask;
1474     SetSignal(oldsignals, STOLEN_SIG);
1475
1476     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1477     {
1478         ReplyMsg(&audioio->ioa_Request.io_Message);
1479     }
1480 }
1481
1482 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1483
1484 /*
1485  *  ReplyWaitCycles
1486  * -----------------
1487  *
1488  * Scans the waitcyclelist and if there are some IOAudio waiting for the end of the wave it reply them to their tasks.
1489  *
1490  */
1491
1492 VOID ReplyWaitCycles(EUNIT *unit, ETASK *eta)
1493 {
1494     struct IOAudio *waitio;
1495
1496     while ((waitio = (struct IOAudio*) RemHead(&unit->eu_waitcyclelist)))
1497     {
1498         D(bug("NEWD: ReplyWaitCycles(): Found IOAuido (%x) in waitcyclelist, now i reply it.\n",
1499             waitio));
1500
1501         ReplyMsg(&waitio->ioa_Request.io_Message);
1502     }
1503 }
1504
1505 /*
1506  *
1507  * ADCMD_WAITCYCLE
1508  *
1509  */
1510
1511 void audio_WAITCYCLE(struct IOAudio *audioio)
1512 {
1513     UBYTE unit;
1514
1515     D(bug("NEWD: Arrived ADCMD_WAITCYCLE from IOAudio (%x), unit(%d)\n",
1516             audioio, audioio->ioa_Request.io_Unit));
1517
1518     unit = (IPTR) audioio->ioa_Request.io_Unit;
1519
1520     PutMsg(global_eta->et_portunits, (struct Message*) audioio); // For the ADCMD_WAITCYCLE only one unit accepted but i send it to the allunit msgport.
1521     Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1522
1523     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1524     {
1525         if (audioio->ioa_Request.io_Error == ADIOERR_NOALLOCATION)
1526         {
1527             ReplyMsg(&audioio->ioa_Request.io_Message);
1528         }
1529         else
1530         {
1531             if (unit != (IPTR) audioio->ioa_Request.io_Unit) // If the value changed it isn't waiting for anyone so please reply.
1532             {
1533                 ReplyMsg(&audioio->ioa_Request.io_Message);
1534             }
1535         }
1536     }
1537 }
1538
1539 /*
1540  *
1541  * _ADCMD_WAITCYCLE
1542  *
1543  */
1544
1545 VOID _ADCMD_WAITCYCLE(struct IOAudio *audioio, ETASK *eta)
1546 {
1547     UBYTE unit, chan; // For the CMD_READ only one unit accepted.
1548     EUNIT *channel;
1549
1550     unit = (IPTR) audioio->ioa_Request.io_Unit;
1551     chan = writechn[unit & 15];
1552
1553     if ((channel = eta->et_units[chan]))
1554     {
1555         if (audioio->ioa_AllocKey == channel->eu_allockey)
1556         {
1557             D(bug("NEWD: Arrived ADCMD_WAITCYCLE from IOAudio (%x),for unit (%d)\n",
1558                 audioio, channel->eu_id));
1559
1560             if (channel->eu_usingme) // Yes there is a wave in execution.
1561             {
1562                 IPTR tmpunit = (IPTR) audioio->ioa_Request.io_Unit;
1563                 tmpunit |= (1 << channel->eu_id);
1564                 audioio->ioa_Request.io_Unit = (APTR) tmpunit;
1565
1566                 audioio->ioa_Request.io_Error = IONOERROR;
1567                 audioio->ioa_Request.io_Flags &= ~IOF_QUICK; // It becames async so clear IOF_QUICK.
1568
1569                 // Put the iorequest in waitcyclelist.
1570                 Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1571                         1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1572
1573                 return;
1574             }
1575             else // No, no wave in execution.
1576             {
1577                 IPTR tmpunit = (IPTR) audioio->ioa_Request.io_Unit;
1578                 tmpunit &= ~(1 << channel->eu_id);
1579                 audioio->ioa_Request.io_Unit = (APTR) tmpunit;
1580
1581                 audioio->ioa_Request.io_Error = IONOERROR;
1582                 Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1583                         1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1584
1585                 return;
1586             }
1587
1588             if (channel->eu_usingme)
1589             {
1590                 audioio->ioa_Data = (UBYTE*) channel->eu_usingme;
1591             }
1592             else
1593             {
1594                 audioio->ioa_Data = NULL;
1595             }
1596
1597             IPTR tmpunit = (IPTR) audioio->ioa_Request.io_Unit;
1598             tmpunit |= (1 << channel->eu_id);
1599             audioio->ioa_Request.io_Unit = (APTR) tmpunit;
1600
1601             audioio->ioa_Request.io_Error = IONOERROR;
1602             Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
1603                     << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1604
1605             return;
1606         }
1607     }
1608
1609     IPTR tmpunit = (IPTR) audioio->ioa_Request.io_Unit;
1610     tmpunit &= ~(1 << channel->eu_id);
1611     audioio->ioa_Request.io_Unit = (APTR) tmpunit;
1612
1613     audioio->ioa_Request.io_Error = ADIOERR_NOALLOCATION;
1614     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
1615             << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1616 }
1617
1618 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1619
1620 VOID StartWaiting(EUNIT *unit, ETASK *eta)
1621 {
1622     struct IOAudio *audioio;
1623
1624     if ((audioio = (struct IOAudio*) RemHead(&unit->eu_writewaitlist)))
1625     {
1626         UnitCopyData(unit, audioio);
1627         UnitInitAhi(unit);
1628
1629         if ((audioio = (struct IOAudio*) RemHead(&unit->eu_writewaitlist)))
1630         {
1631             UnitCopyData(unit, audioio);
1632         }
1633     }
1634 }
1635
1636 /*
1637  *
1638  * _CMD_START
1639  *
1640  * - Here is calles CMD_WRITE but it signals to the port. Pay attention or better remove it.
1641  */
1642
1643 VOID _CMD_START(struct IOAudio *audioio, ETASK *eta)
1644 {
1645     BYTE unit, chan, final = 0;
1646     EUNIT *channel;
1647     UBYTE error = IONOERROR;
1648
1649     D(bug("NEWD: Arrived CMD_START from IOAudio (%x), unit(%d)\n", audioio,
1650             audioio->ioa_Request.io_Unit));
1651
1652     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
1653     {
1654         do
1655         {
1656             chan = writechn[unit]; // Get the lowest channel.
1657             channel = eta->et_units[chan];
1658
1659             if (channel->eu_allockey == audioio->ioa_AllocKey)
1660             {
1661                 final |= 1 << chan; // Ok for this unit the command is successfull.
1662                 channel->eu_status &= ~UNIT_STOP; // The unit now is ready.
1663                 StartWaiting(channel, eta);
1664             }
1665             else
1666             {
1667                 error = ADIOERR_NOALLOCATION;
1668             }
1669
1670             unit &= ~(1 << chan);
1671         } while (unit);
1672     }
1673     else
1674     {
1675         error = ADIOERR_NOALLOCATION;
1676     }
1677
1678     audioio->ioa_Request.io_Unit = (struct Unit*) ((IPTR) final);
1679     audioio->ioa_Request.io_Error = error;
1680     Signal(ematsys->ts_calltask, STOLEN_SIG);
1681 }
1682
1683 /*
1684  *
1685  * ADCMD_START
1686  *
1687  */
1688
1689 void audio_START(struct IOAudio *audioio)
1690 {
1691     ULONG oldsignals;
1692
1693     ematsys->ts_calltask = FindTask(NULL);
1694     oldsignals = SetSignal(0, STOLEN_SIG);
1695
1696     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1697     Wait(STOLEN_SIG);
1698     SetSignal(oldsignals, STOLEN_SIG);
1699
1700     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1701     {
1702         ReplyMsg(&audioio->ioa_Request.io_Message);
1703     }
1704 }
1705
1706 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1707
1708 /*
1709  *
1710  * _CMD_STOP
1711  *
1712  * - I have to stop the audio if the unit was outputting it. But it isn't removed now. I simply abort the AHI. Wait for a program
1713  *   which uses differently CMD_STOP and CMD_START please.
1714  */
1715
1716 VOID _CMD_STOP(struct IOAudio *audioio, ETASK *eta)
1717 {
1718     BYTE unit, chan, final = 0;
1719     EUNIT *channel;
1720     UBYTE error = IONOERROR;
1721
1722     D(bug("NEWD: Arrived CMD_STOP from IOAudio (%x), unit(%d)\n", audioio,
1723             audioio->ioa_Request.io_Unit));
1724
1725     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
1726     {
1727         do
1728         {
1729             chan = writechn[unit]; // Get the lowest channel.
1730             channel = eta->et_units[chan];
1731
1732             if (channel->eu_allockey == audioio->ioa_AllocKey)
1733             {
1734                 final |= 1 << chan; // Ok for this unit the command is successfull.
1735                 channel->eu_status |= UNIT_STOP; // The unit now is stopped.
1736
1737                 // stop the output if there is.
1738
1739                 if (channel->eu_usingme) // Is in execution ?
1740                 {
1741                     if (!(CheckIO((struct IORequest *) &channel->eu_ahireq)))
1742                     {
1743                         AbortIO((struct IORequest *) &channel->eu_ahireq);
1744                         WaitIO((struct IORequest *) &channel->eu_ahireq);
1745                     }
1746
1747                     channel->eu_usingme = NULL; // For now i abort it but probably i have to pay attention more here.
1748                 }
1749
1750             }
1751             else
1752             {
1753                 error = ADIOERR_NOALLOCATION;
1754             }
1755
1756             unit &= ~(1 << chan);
1757         } while (unit);
1758     }
1759     else
1760     {
1761         error = ADIOERR_NOALLOCATION;
1762     }
1763
1764     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
1765     audioio->ioa_Request.io_Error = error;
1766     Signal(ematsys->ts_calltask, STOLEN_SIG);
1767 }
1768
1769 /*
1770  *
1771  * CMD_STOP
1772  *
1773  */
1774
1775 void audio_STOP(struct IOAudio *audioio)
1776 {
1777     ULONG oldsignals;
1778
1779     ematsys->ts_calltask = FindTask(NULL);
1780     oldsignals = SetSignal(0, STOLEN_SIG);
1781
1782     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1783     //Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1784     Wait(STOLEN_SIG);
1785     SetSignal(oldsignals, STOLEN_SIG);
1786
1787     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1788     {
1789         ReplyMsg(&audioio->ioa_Request.io_Message);
1790     }
1791 }
1792
1793 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1794
1795 /*
1796  *
1797  * CMD_READ
1798  *
1799  */
1800
1801 void audio_READ(struct IOAudio *audioio)
1802 {
1803     D(bug("NEWD: Arrived CMD_READ from IOAudio (%x)\n", audioio));
1804
1805     PutMsg(global_eta->et_portunits, (struct Message*) audioio); // For the CMD_READ only one unit accepted but i send it to the allunit msgport.
1806     Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1807
1808     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1809     {
1810         ReplyMsg(&audioio->ioa_Request.io_Message);
1811     }
1812 }
1813
1814 /*
1815  *
1816  * _CMD_READ
1817  *
1818  */
1819
1820 VOID _CMD_READ(struct IOAudio *audioio, ETASK *eta)
1821 {
1822     UBYTE unit, chan; // For the CMD_READ only one unit accepted.
1823     EUNIT *channel;
1824
1825     unit = (IPTR) audioio->ioa_Request.io_Unit;
1826     chan = writechn[unit & 15];
1827
1828     if ((channel = eta->et_units[chan]))
1829     {
1830         if (audioio->ioa_AllocKey == channel->eu_allockey)
1831         {
1832             //if(accessible con io unit)
1833             {
1834                 D(bug("NEWD: Arrived CMD_READ from IOAudio (%x),for unit (%d)\n",
1835                         audioio, channel->eu_id));
1836
1837                 if (channel->eu_usingme)
1838                 {
1839                     audioio->ioa_Data = (UBYTE*) channel->eu_usingme;
1840                 }
1841                 else
1842                 {
1843                     audioio->ioa_Data = NULL;
1844                 }
1845
1846                 IPTR tmpunit = (IPTR) audioio->ioa_Request.io_Unit;
1847                 tmpunit |= (1 << channel->eu_id);
1848                 audioio->ioa_Request.io_Unit = (APTR) tmpunit;
1849
1850                 audioio->ioa_Request.io_Error = IONOERROR;
1851                 Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask,
1852                         1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1853
1854                 return;
1855             }
1856         }
1857     }
1858
1859     IPTR tmpunit = (IPTR) audioio->ioa_Request.io_Unit;
1860     tmpunit &= ~(1 << channel->eu_id);
1861     audioio->ioa_Request.io_Unit = (APTR) tmpunit;
1862
1863     audioio->ioa_Request.io_Error = ADIOERR_NOALLOCATION;
1864     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
1865             << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1866 }
1867
1868 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1869
1870 /*
1871  *
1872  * CMD_RESET
1873  *
1874  */
1875
1876 void audio_RESET(struct IOAudio *audioio)
1877 {
1878     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1879     Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
1880
1881     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1882     {
1883         ReplyMsg(&audioio->ioa_Request.io_Message);
1884     }
1885 }
1886
1887 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1888
1889 /*
1890  *
1891  * ADCMD_FREE
1892  *
1893  */
1894
1895 void audio_FREE(struct IOAudio *audioio)
1896 {
1897     ULONG oldsignals;
1898
1899     D(bug("NEWDD: Sendinf CMD_FREE from IOAudio (%x), unit(%d) key %d\n",
1900             audioio, audioio->ioa_Request.io_Unit, audioio->ioa_AllocKey));
1901
1902     ematsys->ts_calltask = FindTask(NULL);
1903     oldsignals = SetSignal(0, STOLEN_SIG);
1904
1905     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1906     Wait(STOLEN_SIG);
1907
1908     SetSignal(oldsignals, STOLEN_SIG);
1909
1910     D(bug("NEWDD: End of wait state for ADCMD_FREE IoAudio (%d), unit(%d)\n",
1911             audioio, audioio->ioa_Request.io_Unit));
1912
1913     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1914     {
1915         ReplyMsg(&audioio->ioa_Request.io_Message);
1916     }
1917 }
1918
1919 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1920
1921 /*
1922  *
1923  * _CMD_FLUSH
1924  *
1925  */
1926
1927 VOID _CMD_FLUSH(struct IOAudio *audioio, ETASK *eta)
1928 {
1929     BYTE unit, chan, final = 0;
1930     EUNIT *channel;
1931     UBYTE error = IONOERROR;
1932
1933     D(bug("NEWD: Arrived CMD_FLUSH from IOAudio (%x), unit(%d), replyport(%x)\n",
1934         audioio, audioio->ioa_Request.io_Unit, audioio->ioa_Request.io_Message.mn_ReplyPort));
1935
1936     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
1937     {
1938         do
1939         {
1940             chan = writechn[unit];
1941             channel = eta->et_units[chan];
1942
1943             if (channel->eu_allockey == audioio->ioa_AllocKey)
1944             {
1945                 final |= 1 << chan;
1946                 FlushUnit(channel);
1947
1948                 D(bug("NEWD: CMD_FLUSH for unit (%d)\n", chan));
1949             }
1950             else
1951             {
1952                 error = ADIOERR_NOALLOCATION;
1953             }
1954
1955             unit &= ~(1 << chan);
1956         } while (unit);
1957     }
1958     else
1959     {
1960         error = ADIOERR_NOALLOCATION;
1961     }
1962
1963     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
1964     audioio->ioa_Request.io_Error = error;
1965     Signal(ematsys->ts_calltask, STOLEN_SIG);
1966 }
1967
1968 /*
1969  *
1970  * CMD_FLUSH
1971  *
1972  */
1973
1974 void audio_FLUSH(struct IOAudio *audioio)
1975 {
1976     ULONG oldsignals;
1977
1978     ematsys->ts_calltask = FindTask(NULL);
1979
1980     oldsignals = SetSignal(0, STOLEN_SIG); // Change signal set....
1981     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
1982     Wait(STOLEN_SIG);
1983     SetSignal(oldsignals, STOLEN_SIG); // restore signal set.
1984
1985     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
1986     {
1987         ReplyMsg(&audioio->ioa_Request.io_Message);
1988     }
1989 }
1990
1991 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1992
1993 /*
1994  *
1995  * ADCMD_ALLOCATE
1996  *
1997  */
1998
1999 void audio_ALLOCATE(struct IOAudio *audioio)
2000 {
2001     struct Task *oldtask;
2002     ULONG oldsignals;
2003
2004     D(bug("NEWD: ADCMD_ALLOCATE for IOAudio (%x) replyport (%x)\n", audioio,
2005             audioio->ioa_Request.io_Message.mn_ReplyPort));
2006
2007     oldtask = audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask;
2008     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = FindTask(NULL);
2009     oldsignals = SetSignal(0, STOLEN_SIG);
2010
2011     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
2012     Wait(STOLEN_SIG);
2013
2014     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = oldtask;
2015     SetSignal(oldsignals, STOLEN_SIG);
2016
2017     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
2018     {
2019         if ((audioio->ioa_Request.io_Error == ADIOERR_ALLOCFAILED)
2020                 && (audioio->ioa_Request.io_Flags & ADIOF_NOWAIT))
2021         {
2022             ReplyMsg(&audioio->ioa_Request.io_Message);
2023         }
2024         else if (audioio->ioa_Request.io_Error == IONOERROR)
2025         {
2026             ReplyMsg(&audioio->ioa_Request.io_Message);
2027         }
2028     }
2029 }
2030
2031 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2032
2033 /*
2034  *
2035  * CMD_WRITE
2036  *
2037  */
2038
2039 void audio_WRITE(struct IOAudio *audioio)
2040 {
2041     UBYTE unit, chan; // For the CMD_WRITE only one unit accepted.
2042     struct Task *oldtask;
2043     ULONG oldsignals;
2044
2045     D(bug("NEWDD: Received ADCMD_WRITE from task %x\n", FindTask(NULL)));
2046
2047     unit = (IPTR) audioio->ioa_Request.io_Unit;
2048     chan = writechn[unit & 15];
2049
2050     oldtask = audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask;
2051     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = FindTask(NULL);
2052     oldsignals = SetSignal(0, STOLEN_SIG);
2053
2054     PutMsg(global_eta->et_ports[chan], (struct Message*) audioio);
2055     Wait(STOLEN_SIG);
2056
2057     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = oldtask;
2058     SetSignal(oldsignals, STOLEN_SIG);
2059 }
2060
2061 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2062
2063
2064 BOOL AbortIOUnit(struct IOAudio *audioio, EUNIT *unit)
2065 {
2066     if (unit->eu_audioio == audioio) // Is in pre-cache?
2067     {
2068         unit->eu_audioio = NULL;
2069         //audioio->ioa_Request.io_Error = IONOERROR;
2070
2071         D(bug("NEWD: ABORTIO IOAudio %x was in pre-cache, now replied\n",
2072             audioio));
2073         return 1;
2074     }
2075
2076     if (unit->eu_usingme == audioio) // Is in execution ?
2077     {
2078         if (!(CheckIO((struct IORequest *) &unit->eu_ahireq)))
2079         {
2080             D(bug("NEWD: It was really in execution\n"));
2081
2082             AbortIO((struct IORequest *) &unit->eu_ahireq);
2083             WaitIO((struct IORequest *) &unit->eu_ahireq);
2084         }
2085
2086         unit->eu_usingme = NULL;
2087         //audioio->ioa_Request.io_Error = IONOERROR;
2088
2089         D(bug("NEWD: ABORTIO IOAudio %x was in execution, stopped and replied\n",
2090             audioio));
2091
2092         return 1;
2093     }
2094     return 0;
2095 }
2096
2097 /*
2098  *
2099  * _CMD_ABORTIO
2100  *
2101  * - Remember that AbortIO() could not suspend the wave soon but has to wait for the cycle end. Page 127 RKM.
2102  */
2103
2104 VOID _CMD_ABORTIO(struct IOAudio *audioio, ETASK *eta)
2105 {
2106     UBYTE actunit = 0;
2107     BOOL result;
2108
2109     D(bug("NEWD: Received CMD_ABORTIO for IOAudio %x\n", audioio));
2110
2111     do // First of all verify if the ioaudio is the one present in each unit channel.
2112     {
2113         if ((result = AbortIOUnit(audioio, eta->et_units[actunit])))
2114         {
2115             break;
2116         }
2117     } while (++actunit < 4);
2118
2119     if (!result) // If it isn't surely it stay in any list. Remove it and reply with IOERR_ABORTED
2120     {
2121         Remove(&audioio->ioa_Request.io_Message.mn_Node); // Whereever you are remove it.
2122         audioio->ioa_Request.io_Error = IOERR_ABORTED;
2123
2124         D(bug("NEWD: ABORTIO IOAudio %x not in pre-cache not in execution\n",
2125                 audioio));
2126     }
2127
2128     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, STOLEN_SIG);
2129
2130     /*
2131      actunit = 0;
2132
2133      do
2134      {
2135      UnitReWrite(eta->et_units[actunit]);
2136      } while(++actunit < 4);
2137      */
2138 }
2139
2140 /*
2141  *
2142  * CMD_ABORTIO
2143  *
2144  */
2145
2146 VOID audio_ABORTIO(struct IOAudio *audioio, ETASK *eta)
2147 {
2148     UWORD oldcmd;
2149     struct Task *oldtask;
2150     ULONG oldsignals;
2151
2152     oldcmd = audioio->ioa_Request.io_Command;
2153     audioio->ioa_Request.io_Command = CMD_ABORTIO;
2154
2155     oldtask = audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask;
2156     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = FindTask(NULL);
2157     oldsignals = SetSignal(0, STOLEN_SIG);
2158     PutMsg(eta->et_portunits, (struct Message*) audioio);
2159
2160     Wait(STOLEN_SIG);
2161
2162     audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask = oldtask;
2163     SetSignal(oldsignals, STOLEN_SIG);
2164
2165     audioio->ioa_Request.io_Command = oldcmd;
2166     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
2167         ReplyMsg(&audioio->ioa_Request.io_Message);
2168 }
2169
2170 /*
2171  *
2172  * _CMD_CLOSE
2173  *
2174  */
2175
2176 VOID _CMD_CLOSE(struct IOAudio *audioio, ETASK *eta)
2177 {
2178     D(bug("NEWD: SLAVE PROCESS OPERATING END by CMD_CLOSE\n"));
2179
2180     free_ETask(eta);
2181
2182     Signal(ematsys->ts_calltask, STOLEN_SIG);
2183 }
2184
2185 /*
2186  *
2187  * CMD_CLOSE
2188  *
2189  */
2190
2191 VOID audio_CLOSE(struct IOAudio *audioio, ETASK *eta)
2192 {
2193     UWORD oldcmd;
2194     ULONG oldsignals;
2195
2196     oldcmd = audioio->ioa_Request.io_Command;
2197     audioio->ioa_Request.io_Command = CMD_CLOSE;
2198
2199     ematsys->ts_calltask = FindTask(NULL);
2200     oldsignals = SetSignal(0, STOLEN_SIG);
2201
2202     PutMsg(eta->et_portunits, (struct Message*) audioio);
2203     Wait(STOLEN_SIG);
2204
2205     SetSignal(oldsignals, STOLEN_SIG);
2206     audioio->ioa_Request.io_Command = oldcmd;
2207 }
2208
2209 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2210
2211 /*
2212  *
2213  * _CMD_CLEAR
2214  *
2215  */
2216
2217 VOID _CMD_CLEAR(struct IOAudio *audioio, ETASK *eta)
2218 {
2219     BYTE unit, chan, final = 0;
2220     EUNIT *channel;
2221     UBYTE error = IONOERROR;
2222
2223     D(bug("NEWD: Arrived CMD_CLEAR from IOAudio (%x), unit(%d)\n", audioio,
2224             audioio->ioa_Request.io_Unit));
2225
2226     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
2227     {
2228         do
2229         {
2230             chan = writechn[unit]; // Get the lowest channel.
2231             channel = eta->et_units[chan];
2232
2233             if (channel->eu_allockey == audioio->ioa_AllocKey)
2234             {
2235                 final |= 1 << chan; // Ok for this unit the command is successfull.
2236             }
2237             else
2238             {
2239                 error = ADIOERR_NOALLOCATION;
2240             }
2241
2242             unit &= ~(1 << chan);
2243         } while (unit);
2244     }
2245     else
2246     {
2247         error = ADIOERR_NOALLOCATION;
2248     }
2249
2250     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
2251     audioio->ioa_Request.io_Error = error;
2252     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
2253             << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
2254 }
2255
2256 /*
2257  *
2258  * CMD_CLEAR
2259  *
2260  */
2261
2262 void audio_CLEAR(struct IOAudio *audioio)
2263 {
2264     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
2265     Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
2266
2267     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
2268     {
2269         ReplyMsg(&audioio->ioa_Request.io_Message);
2270     }
2271 }
2272
2273 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2274
2275 /*
2276  *
2277  * _CMD_UPDATE
2278  *
2279  */
2280
2281 VOID _CMD_UPDATE(struct IOAudio *audioio, ETASK *eta)
2282 {
2283     BYTE unit, chan, final = 0;
2284     EUNIT *channel;
2285     UBYTE error = IONOERROR;
2286
2287     D(bug("NEWD: Arrived CMD_UPDATE from IOAudio (%x), unit(%d)\n", audioio,
2288             audioio->ioa_Request.io_Unit));
2289
2290     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
2291     {
2292         do
2293         {
2294             chan = writechn[unit]; // Get the lowest channel.
2295             channel = eta->et_units[chan];
2296
2297             if (channel->eu_allockey == audioio->ioa_AllocKey)
2298             {
2299                 final |= 1 << chan; // Ok for this unit the command is successfull.
2300             }
2301             else
2302             {
2303                 error = ADIOERR_NOALLOCATION;
2304             }
2305
2306             unit &= ~(1 << chan);
2307         } while (unit);
2308     }
2309     else
2310     {
2311         error = ADIOERR_NOALLOCATION;
2312     }
2313
2314     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
2315     audioio->ioa_Request.io_Error = error;
2316     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
2317             << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
2318 }
2319
2320 /*
2321  *
2322  * CMD_UPDATE
2323  *
2324  */
2325
2326 void audio_UPDATE(struct IOAudio *audioio)
2327 {
2328     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
2329     Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
2330
2331     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
2332     {
2333         ReplyMsg(&audioio->ioa_Request.io_Message);
2334     }
2335 }
2336
2337 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2338
2339
2340 /*
2341  *
2342  * _ADCMD_SETPREC
2343  *
2344  */
2345
2346 VOID _ADCMD_SETPREC(struct IOAudio *audioio, ETASK *eta)
2347 {
2348     BYTE unit, chan, final = 0;
2349     EUNIT *channel;
2350     UBYTE error = IONOERROR;
2351
2352     D(bug("NEWD: Arrived ADCMD_SETPREC from IOAudio (%x), unit(%d)\n", audioio,
2353             audioio->ioa_Request.io_Unit));
2354
2355     if ((unit = (((IPTR) audioio->ioa_Request.io_Unit) & 15)))
2356     {
2357         do
2358         {
2359             chan = writechn[unit]; // Get the lowest channel.
2360             channel = eta->et_units[chan];
2361
2362             if (channel->eu_allockey == audioio->ioa_AllocKey)
2363             {
2364                 final |= 1 << chan; // Ok for this unit the command is successfull.
2365                 channel->eu_pri
2366                         = audioio->ioa_Request.io_Message.mn_Node.ln_Pri; // Ok, for this unit change the priority.
2367             }
2368             else
2369             {
2370                 error = ADIOERR_NOALLOCATION;
2371             }
2372
2373             unit &= ~(1 << chan);
2374         } while (unit);
2375     }
2376     else
2377     {
2378         error = ADIOERR_NOALLOCATION;
2379     }
2380
2381     audioio->ioa_Request.io_Unit = (struct Unit*) (IPTR) final;
2382     audioio->ioa_Request.io_Error = error;
2383     Signal(audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigTask, 1
2384             << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
2385
2386     // Now, because the priority of the channel is modified retry, if there are, to allocate some waiting requests for.
2387
2388     if (unit)
2389     {
2390         ReAllocateUnits(eta);
2391     }
2392 }
2393
2394 /*
2395  *
2396  * ADCMD_SETPREC
2397  *
2398  */
2399
2400 void audio_SETPREC(struct IOAudio *audioio)
2401 {
2402     PutMsg(global_eta->et_portunits, (struct Message*) audioio);
2403     Wait(1 << audioio->ioa_Request.io_Message.mn_ReplyPort->mp_SigBit);
2404
2405     if ((audioio->ioa_Request.io_Flags & IOF_QUICK) == 0)
2406     {
2407         ReplyMsg(&audioio->ioa_Request.io_Message);
2408     }
2409 }
2410
2411 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////