workbench/libs/realtime/setconductorstate.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #include <proto/exec.h>
  10 #include <proto/alib.h>
  11 #include <proto/utility.h>
  12 #include <proto/realtime.h>
  13 #include <exec/lists.h>
  14 #include "realtime_intern.h"
  15
  16 /*****************************************************************************
  17
  18     NAME */
  19 #include <libraries/realtime.h>
  20
  21     AROS_LH3(LONG, SetConductorState,
  22
  23 /*  SYNOPSIS */
  24
  25         AROS_LHA(struct Player *, player, A0),
  26         AROS_LHA(ULONG          , state , D0),
  27         AROS_LHA(LONG           , time  , D1),
  28
  29 /*  LOCATION */
  30
  31         struct Library *, RealTimeBase, 10, RealTime)
  32
  33 /*  FUNCTION
  34
  35     Changes the state of the conductor connected to a specified player.
  36     The possible states are
  37
  38     CONDSTATE_STOPPED
  39     CONDSTATE_PAUSED
  40     CONDSTATE_LOCATE
  41     CONDSTATE_RUNNING
  42
  43     other possible "states" are
  44
  45     CONDSTATE_METRIC   --  Ask the highest priority conducted node to do a
  46                            CONDSTATE_LOCATE
  47     CONDSTATE_SHUTTLE  --  Inform the players that the clock value is
  48                            changing without the clock running
  49
  50
  51     INPUTS
  52
  53     player   --  The player in question
  54     state    --  The new state of the conductor
  55     time     --  Start time offset in realtime.library units
  56
  57     RESULT
  58
  59     0 if OK, otherwise an error code. For now, these are RTE_PLAYING and
  60     RTE_NOCONDUCTOR.
  61
  62     NOTES
  63
  64     Going from CONDSTATE_PAUSED to CONDSTATE_RUNNING does not reset the
  65     cdt_ClockTime of the conductor.
  66
  67     EXAMPLE
  68
  69     BUGS
  70
  71     SEE ALSO
  72
  73     INTERNALS
  74
  75     HISTORY
  76
  77     27.7.1999  SDuvan  implemented parts
  78     27.1.2001  SDuvan  implemented the rest
  79
  80 ******************************************************************************/
  81
  82 {
  83     AROS_LIBFUNC_INIT
  84
  85     struct pmState    stateMsg = { PM_STATE, 0 };
  86     struct pmTime     timeMsg  = { 0 , time };
  87     struct Player    *pl;    /* For use in ForeachNode() */
  88     struct Conductor *conductor = player->pl_Source;
  89
  90     if (conductor == NULL)
  91     {
  92         return RTE_NOCONDUCTOR;
  93     }
  94
  95     stateMsg.pms_OldState = conductor->cdt_State;
  96
  97     /* Don't report phony states */
  98     if (state >= 0)
  99     {
 100         ForeachNode(&conductor->cdt_Players, pl)
 101         {
 102             /* Filter out QUIET players? */
 103             if (pl->pl_Hook != NULL)
 104             {
 105                 CallHookA(pl->pl_Hook, &stateMsg, player);
 106             }
 107         }
 108     }
 109
 110     switch (state)
 111     {
 112     case CONDSTATE_PAUSED:
 113
 114         /* Pause the clock */
 115         conductor->cdt_State = CONDSTATE_PAUSED;
 116         conductor->cdt_Flags &= ~CONDUCTF_GOTTICK;
 117
 118         break;
 119
 120     case CONDSTATE_STOPPED:
 121
 122         /* Stop the clock */
 123         conductor->cdt_State = CONDSTATE_STOPPED;
 124         conductor->cdt_Flags &= ~CONDUCTF_GOTTICK;
 125
 126         break;
 127
 128     case CONDSTATE_LOCATE:
 129         {
 130             ULONG oldSignals;
 131
 132             conductor->cdt_State = CONDSTATE_LOCATE;
 133
 134             ObtainSemaphore(&conductor->cdt_Lock);
 135             oldSignals = SetSignal(0, SIGF_SINGLE);
 136             conductor->cdt_Barrier = FindTask(NULL);
 137             ReleaseSemaphore(&conductor->cdt_Lock);
 138
 139             ForeachNode(&conductor->cdt_Players, pl)
 140             {
 141                 BOOL isReady = FALSE;
 142
 143                 /* Barrier synchronization */
 144                 while (!isReady)
 145                 {
 146                     struct TagItem tags[] = { { PLAYER_Ready, (IPTR)&isReady },
 147                                               { TAG_DONE    , (IPTR)NULL   } };
 148
 149                     GetPlayerAttrsA(pl, tags);
 150
 151                     if (!isReady)
 152                     {
 153                         /* We are signalled by SetPlayerAttrs() if the tags
 154                            contain PLAYER_Ready '=' TRUE) */
 155                         Wait(SIGF_SINGLE);
 156                     }
 157                 }
 158             }
 159
 160             ObtainSemaphore(&conductor->cdt_Lock);
 161             conductor->cdt_Barrier = NULL;
 162             SetSignal(oldSignals, SIGF_SINGLE);
 163             ReleaseSemaphore(&conductor->cdt_Lock);
 164         }
 165
 166         /* Send PM_STATE message with CONDSTATE_LOCATE_SET here? */
 167
 168         /* Fall through */
 169
 170     case CONDSTATE_RUNNING:
 171         /* Start clock */
 172         conductor->cdt_ClockTime = time;
 173         conductor->cdt_State = CONDSTATE_RUNNING;
 174
 175         break;
 176
 177     case CONDSTATE_METRIC:
 178         {
 179             /* Get the highest priority musically aware player and let him
 180                take care of the time location process. He will later call
 181                SetConductorState() with state CONDSTATE_LOCATE to set the
 182                time in realtime units calculated from his internal awareness
 183                of time. */
 184             struct Player *maestro = NULL;
 185
 186             ForeachNode(&conductor->cdt_Players,pl)
 187             {
 188                 if (pl->pl_Flags & PLAYERF_CONDUCTED)
 189                 {
 190                     maestro = pl;
 191                     break;
 192                 }
 193             }
 194
 195             if (maestro == NULL)
 196             {
 197                 /* There is no defined error to return in this situation */
 198             }
 199             else
 200             {
 201                 timeMsg.pmt_Method = PM_POSITION;
 202                 CallHookA(maestro->pl_Hook, &timeMsg, player);
 203             }
 204
 205             break;
 206         }
 207
 208     case CONDSTATE_SHUTTLE:
 209         /* Shuttling not allowed when playing */
 210         if (conductor->cdt_State == CONDSTATE_RUNNING)
 211         {
 212             return RTE_PLAYING;
 213         }
 214
 215         conductor->cdt_StartTime = time;
 216
 217         timeMsg.pmt_Method = PM_SHUTTLE;
 218
 219         ForeachNode(&conductor->cdt_Players, pl)
 220         {
 221             if (pl->pl_Hook != NULL)
 222             {
 223                 CallHookA(pl->pl_Hook, &timeMsg, player);
 224             }
 225         }
 226
 227         break;
 228     }
 229
 230     return 0;                   /* Success */
 231
 232     AROS_LIBFUNC_EXIT
 233 } /* SetConductorState */