workbench/devs/AHI/Drivers/Device/device-playslave.c

   1
   2 #include <config.h>
   3
   4 #include <devices/ahi.h>
   5 #include <dos/dos.h>
   6 #include <exec/execbase.h>
   7 #include <libraries/ahi_sub.h>
   8 #include <proto/ahi.h>
   9 #include <proto/exec.h>
  10 #include <proto/utility.h>
  11
  12 #include <string.h>
  13
  14 #include "DriverData.h"
  15 #include "library.h"
  16
  17 #define dd ((struct DeviceData*) AudioCtrl->ahiac_DriverData)
  18
  19 /******************************************************************************
  20 ** The slave process **********************************************************
  21 ******************************************************************************/
  22
  23 #undef SysBase
  24
  25 static void Slave( struct ExecBase* SysBase );
  26
  27 #if defined( __AROS__ )
  28
  29 #include <aros/asmcall.h>
  30
  31 AROS_UFH3(LONG, SlaveEntry,
  32           AROS_UFHA(STRPTR, argPtr, A0),
  33           AROS_UFHA(ULONG, argSize, D0),
  34           AROS_UFHA(struct ExecBase *, SysBase, A6))
  35 {
  36    AROS_USERFUNC_INIT
  37    Slave( SysBase );
  38    return 0;
  39    AROS_USERFUNC_EXIT
  40 }
  41
  42 #else
  43
  44 void SlaveEntry(void)
  45 {
  46   struct ExecBase* SysBase = *((struct ExecBase**) 4);
  47
  48   Slave( SysBase );
  49 }
  50
  51 #endif
  52
  53
  54 static void
  55 Slave( struct ExecBase* SysBase )
  56 {
  57   struct AHIAudioCtrlDrv* AudioCtrl;
  58   struct DriverBase*      AHIsubBase;
  59   BOOL                    running;
  60   ULONG                   signals;
  61
  62   /* Note that in OS4, we cannot call FindTask(NULL) here, since IExec
  63    * is inside AHIsubBase! */
  64   AudioCtrl  = (struct AHIAudioCtrlDrv*) FindTask(NULL)->tc_UserData;
  65   AHIsubBase = (struct DriverBase*) dd->ahisubbase;
  66
  67   dd->slavesignal = AllocSignal( -1 );
  68
  69   if( dd->slavesignal != -1 )
  70   {
  71     struct MsgPort*    ahi_mp           = NULL;
  72     struct AHIRequest* ahi_iorequest    = NULL;
  73     APTR               ahi_iocopy       = NULL;
  74     BYTE               ahi_device       = -1;
  75
  76     struct AHIRequest* ahi_io[ 2 ]      = { NULL,  NULL };
  77     BOOL               ahi_io_used[ 2 ] = { FALSE, FALSE };
  78
  79     ULONG              frame_length     = 0;
  80
  81     ahi_mp = CreateMsgPort();
  82
  83     if( ahi_mp != NULL )
  84     {
  85       ahi_iorequest = (struct AHIRequest*) CreateIORequest( ahi_mp, sizeof( struct AHIRequest ) );
  86
  87       if( ahi_iorequest != NULL )
  88       {
  89         ahi_iorequest->ahir_Version = 4;
  90
  91         ahi_device = OpenDevice( AHINAME, dd->unit,
  92                                  (struct IORequest*) ahi_iorequest, 0 );
  93
  94         if( ahi_device == 0 )
  95         {
  96           struct Library* AHIBase = (struct Library*) ahi_iorequest->ahir_Std.io_Device;
  97 #ifdef __AMIGAOS4__
  98           struct AHIIFace* IAHI = (struct AHIIFace*) GetInterface(AHIBase, "main", 1, NULL);
  99 #endif
 100
 101           ahi_iocopy = AllocVec( sizeof( *ahi_iorequest ), MEMF_ANY );
 102
 103           if( ahi_iocopy != NULL )
 104           {
 105             bcopy( ahi_iorequest, ahi_iocopy, sizeof( *ahi_iorequest ) );
 106
 107             ahi_io[ 0 ] = ahi_iorequest;
 108             ahi_io[ 1 ] = ahi_iocopy;
 109
 110             // Everything set up. Tell Master we're alive and healthy.
 111
 112             Signal( (struct Task*) dd->mastertask,
 113                     1L << dd->mastersignal );
 114
 115             running = TRUE;
 116
 117             // The main playback loop follow
 118
 119             while( running )
 120             {
 121               int skip_mix;
 122               APTR tmp_buff;
 123               struct AHIRequest* tmp_io;
 124
 125               if( ahi_io_used[ 0 ] )
 126               {
 127                 LONG  err;
 128                 ULONG mask = ( SIGBREAKF_CTRL_C |
 129                                (1L << dd->slavesignal) |
 130                                (1L << ahi_mp->mp_SigBit) );
 131
 132                 signals = Wait( mask );
 133
 134                 if( signals & ( SIGBREAKF_CTRL_C |
 135                                 (1L << dd->slavesignal) ) )
 136                 {
 137                   running = FALSE;
 138                   break;
 139                 }
 140
 141                 err = WaitIO( (struct IORequest*) ahi_io[ 0 ] );
 142
 143                 if( err != 0 )
 144                 {
 145                   KPrintF( DRIVER ": AHI device error %ld\n", err );
 146 //                running = FALSE;
 147                   break;
 148                 }
 149               }
 150
 151               skip_mix = CallHookPkt( AudioCtrl->ahiac_PreTimerFunc,
 152                                       (Object*) AudioCtrl, 0 );
 153
 154               CallHookPkt( AudioCtrl->ahiac_PlayerFunc, AudioCtrl, NULL );
 155
 156               if( ! skip_mix )
 157               {
 158                 CallHookPkt( AudioCtrl->ahiac_MixerFunc, AudioCtrl,
 159                              dd->mixbuffers[ 0 ] );
 160               }
 161
 162               CallHookPkt( AudioCtrl->ahiac_PostTimerFunc, (Object*) AudioCtrl, 0 );
 163
 164               if( frame_length == 0 )
 165               {
 166                 frame_length = AHI_SampleFrameSize( AudioCtrl->ahiac_BuffType );
 167               }
 168
 169               ahi_io[ 0 ]->ahir_Std.io_Command = CMD_WRITE;
 170               ahi_io[ 0 ]->ahir_Std.io_Data    = dd->mixbuffers[ 0 ];
 171               ahi_io[ 0 ]->ahir_Std.io_Length  = ( AudioCtrl->ahiac_BuffSamples *
 172                                                    frame_length );
 173               ahi_io[ 0 ]->ahir_Std.io_Offset  = 0;
 174               ahi_io[ 0 ]->ahir_Frequency      = AudioCtrl->ahiac_MixFreq;
 175               ahi_io[ 0 ]->ahir_Type           = AudioCtrl->ahiac_BuffType;
 176               ahi_io[ 0 ]->ahir_Volume         = 0x10000;
 177               ahi_io[ 0 ]->ahir_Position       = 0x08000;
 178               ahi_io[ 0 ]->ahir_Link           = ( ahi_io_used[ 1 ] ?
 179                                                    ahi_io[ 1 ] : NULL );
 180
 181               SendIO( (struct IORequest*) ahi_io[ 0 ] );
 182
 183               tmp_io = ahi_io[ 0 ];
 184               ahi_io[ 0 ] = ahi_io[ 1 ];
 185               ahi_io[ 1 ] = tmp_io;
 186
 187               tmp_buff = dd->mixbuffers[ 0 ];
 188               dd->mixbuffers[ 0 ] = dd->mixbuffers[ 1 ];
 189               dd->mixbuffers[ 1 ] = tmp_buff;
 190
 191               ahi_io_used[ 0 ] = ahi_io_used[ 1 ];
 192               ahi_io_used[ 1 ] = TRUE;
 193             }
 194
 195
 196             if( ahi_io_used[ 0 ] )
 197             {
 198               AbortIO( (struct IORequest*) ahi_io[ 0 ] );
 199               WaitIO( (struct IORequest*) ahi_io[ 0 ] );
 200             }
 201
 202             if( ahi_io_used[ 1 ] )
 203             {
 204               AbortIO( (struct IORequest*) ahi_io[ 1 ] );
 205               WaitIO( (struct IORequest*) ahi_io[ 1 ] );
 206             }
 207
 208             FreeVec( ahi_iocopy );
 209           }
 210
 211 #ifdef __AMIGAOS4__
 212           DropInterface((struct Interface*) IAHI);
 213 #endif
 214           CloseDevice( (struct IORequest*) ahi_iorequest );
 215         }
 216
 217         DeleteIORequest( (struct IORequest*) ahi_iorequest );
 218       }
 219
 220       DeleteMsgPort( ahi_mp );
 221     }
 222   }
 223
 224   FreeSignal( dd->slavesignal );
 225   dd->slavesignal = -1;
 226
 227   Forbid();
 228
 229   // Tell the Master we're dying
 230
 231   Signal( (struct Task*) dd->mastertask,
 232           1L << dd->mastersignal );
 233
 234   dd->slavetask = NULL;
 235
 236   // Multitasking will resume when we are dead.
 237 }