workbench/devs/AHI/Drivers/Alsa/alsa-playslave.c

   1 /*
   2     Copyright © 2015-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7 #include <config.h>
   8
   9 #include <devices/ahi.h>
  10 #include <exec/execbase.h>
  11 #include <libraries/ahi_sub.h>
  12
  13 #include "DriverData.h"
  14 #include "library.h"
  15
  16 #include "alsa-bridge/alsa.h"
  17
  18 #define dd ((struct AlsaData*) AudioCtrl->ahiac_DriverData)
  19
  20 #define min(a,b) ( (a) < (b) ? (a) : (b) )
  21
  22 /******************************************************************************
  23 ** The slave process **********************************************************
  24 ******************************************************************************/
  25
  26 #undef SysBase
  27
  28 void Slave( struct ExecBase* SysBase );
  29
  30 #include <aros/asmcall.h>
  31
  32 AROS_UFH3(LONG, SlaveEntry,
  33       AROS_UFHA(STRPTR, argPtr, A0),
  34       AROS_UFHA(ULONG, argSize, D0),
  35       AROS_UFHA(struct ExecBase *, SysBase, A6))
  36 {
  37    AROS_USERFUNC_INIT
  38    Slave( SysBase );
  39    return 0;
  40    AROS_USERFUNC_EXIT
  41 }
  42
  43 #include <hardware/intbits.h>
  44 #include <proto/timer.h>
  45
  46 AROS_INTH1(AHITimerTickCode, struct Task *, task)
  47 {
  48     AROS_INTFUNC_INIT
  49     Signal(task, SIGBREAKF_CTRL_F);
  50     return 0;
  51
  52     AROS_INTFUNC_EXIT
  53 }
  54
  55
  56
  57 static void SmallDelay(struct ExecBase *SysBase)
  58 {
  59     struct Interrupt i;
  60
  61     i.is_Code         = (APTR)AHITimerTickCode;
  62     i.is_Data         = FindTask(0);
  63     i.is_Node.ln_Name = "AROS AHI Driver Timer Tick Server";
  64     i.is_Node.ln_Pri  = 0;
  65     i.is_Node.ln_Type = NT_INTERRUPT;
  66
  67     SetSignal(0, SIGBREAKF_CTRL_F);
  68     AddIntServer(INTB_VERTB, &i);
  69     Wait(SIGBREAKF_CTRL_F);
  70     RemIntServer(INTB_VERTB, &i);
  71 }
  72
  73 void
  74 Slave( struct ExecBase* SysBase )
  75 {
  76   struct AHIAudioCtrlDrv* AudioCtrl;
  77   struct DriverBase*      AHIsubBase;
  78   BOOL                    running;
  79   ULONG                   signals;
  80   LONG                    framesready = 0;
  81   APTR                    framesptr = NULL;
  82
  83   AudioCtrl  = (struct AHIAudioCtrlDrv*) FindTask(NULL)->tc_UserData;
  84   AHIsubBase = (struct DriverBase*) dd->ahisubbase;
  85   dd->slavesignal = AllocSignal( -1 );
  86
  87   if( dd->slavesignal != -1 )
  88   {
  89     // Everything set up. Tell Master we're alive and healthy.
  90
  91     Signal( (struct Task*) dd->mastertask,
  92             1L << dd->mastersignal );
  93
  94     running = TRUE;
  95
  96     while( running )
  97     {
  98       signals = SetSignal(0L,0L);
  99
 100       if( signals & ( SIGBREAKF_CTRL_C | (1L << dd->slavesignal) ) )
 101       {
 102         running = FALSE;
 103       }
 104       else
 105       {
 106         LONG framesfree = 0;
 107         LONG readcycles = 0;
 108
 109         while(TRUE)
 110         {
 111           framesfree = ALSA_Avail(dd->alsahandle);
 112           if (framesfree == ALSA_XRUN)
 113           {
 114               D(bug("[Alsa] ALSA_Avail() == XRUN\n"));
 115               ALSA_Prepare(dd->alsahandle);
 116               framesfree = ALSA_Avail(dd->alsahandle);
 117           }
 118
 119           if (framesfree >= 64)
 120           {
 121             readcycles++;
 122             if (framesfree >= AudioCtrl->ahiac_BuffSamples)
 123               readcycles++;
 124             break;
 125           }
 126
 127           SmallDelay(SysBase);
 128         }
 129
 130         /* Loop until alsa buffer is filled */
 131         while (framesfree > 0)
 132         {
 133           LONG written;
 134
 135           if (framesready == 0)
 136           {
 137             if (readcycles == 0)
 138               break;
 139
 140             CallHookPkt(AudioCtrl->ahiac_PlayerFunc, AudioCtrl, NULL );
 141             CallHookPkt(AudioCtrl->ahiac_MixerFunc, AudioCtrl, dd->mixbuffer );
 142             framesready = AudioCtrl->ahiac_BuffSamples;
 143             framesptr = dd->mixbuffer;
 144             readcycles--;
 145           }
 146
 147           written = ALSA_Write(dd->alsahandle, framesptr, min(framesready,
 148                   framesfree));
 149           if (written == ALSA_XRUN)
 150           {
 151               D(bug("[Alsa] ALSA_Write() == XRUN %d, %d\n", framesfree, framesready));
 152               ALSA_Prepare(dd->alsahandle);
 153               written = ALSA_Write(dd->alsahandle, framesptr, min(framesready,
 154                       framesfree));
 155           }
 156
 157           framesready -= written;
 158           framesfree  -= written;
 159           framesptr += written * 4;
 160
 161           CallHookA(AudioCtrl->ahiac_PostTimerFunc, (Object*) AudioCtrl, 0);
 162         }
 163       }
 164     }
 165   }
 166
 167   FreeSignal( dd->slavesignal );
 168   dd->slavesignal = -1;
 169
 170   Forbid();
 171
 172   // Tell the Master we're dying
 173
 174   Signal( (struct Task*) dd->mastertask, 1L << dd->mastersignal );
 175
 176   dd->slavetask = NULL;
 177
 178   // Multitaking will resume when we are dead.
 179 }