workbench/libs/realtime/setplayerattrsa.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 #include <proto/exec.h>
   6 #include <proto/utility.h>
   7 #include <proto/realtime.h>
   8 #include <exec/lists.h>
   9 #include "realtime_intern.h"
  10
  11 /*****************************************************************************
  12
  13     NAME */
  14
  15 #include <utility/tagitem.h>
  16 #include <libraries/realtime.h>
  17
  18     AROS_LH2(BOOL, SetPlayerAttrsA,
  19
  20 /*  SYNOPSIS */
  21
  22         AROS_LHA(struct Player  *, player , A0),
  23         AROS_LHA(struct TagItem *, tagList, A1),
  24
  25 /*  LOCATION */
  26
  27         struct Library *, RealTimeBase, 9, RealTime)
  28
  29 /*  FUNCTION
  30
  31     Sets the attributes of a player. An attribute not specified in the array
  32     of tags is unchanged after this procedure.
  33
  34     INPUTS
  35
  36     player   --  The player the attributes of which to set.
  37     tagList  --  Pointer to an array of tags describing the player's
  38                  attributes or NULL.
  39
  40     TAGS
  41
  42     The same tags as for CreatePlayerA().
  43
  44     RESULT
  45
  46     Success/failure indicator. If failure, then, in case the PLAYER_ErrorCode
  47     is provided, more information can be obtained via that pointer.
  48
  49     NOTES
  50
  51     EXAMPLE
  52
  53     BUGS
  54
  55     SEE ALSO
  56
  57     DeletePlayer(), GetPlayerAttrsA()
  58
  59     INTERNALS
  60
  61 ******************************************************************************/
  62
  63 {
  64     AROS_LIBFUNC_INIT
  65
  66     LONG           *error = NULL;
  67     const struct TagItem *tl = tagList;
  68     struct TagItem *tag;
  69     APTR            lock;
  70
  71     error = (LONG *)GetTagData(PLAYER_ErrorCode, NULL, tl);
  72
  73     while ((tag = NextTagItem(&tl)) != NULL)
  74     {
  75         switch(tag->ti_Tag)
  76         {
  77         case PLAYER_Name:
  78             player->pl_Link.ln_Name = (APTR)tag->ti_Data;
  79             break;
  80
  81         case PLAYER_Hook:
  82             player->pl_Hook = (struct Hook *)tag->ti_Data;
  83             break;
  84
  85         case PLAYER_Priority:
  86             player->pl_Link.ln_Pri = (BYTE)tag->ti_Data;
  87
  88             if (player->pl_Link.ln_Succ != NULL)
  89             {
  90                 /* If this node has been (is) inserted before, then remove it
  91                    and put it in the right place. */
  92
  93                 /* Is this player attached to a conductor? */
  94                 if (player->pl_Source != NULL)
  95                 {
  96                     lock = LockRealTime(RT_CONDUCTORS);
  97                     Remove((struct Node *)player);
  98                     Enqueue((struct List *)&player->pl_Source->cdt_Players,
  99                             (struct Node *)player);
 100                     UnlockRealTime(lock);
 101                 }
 102                 else
 103                 {
 104                     if(error != NULL)
 105                     {
 106                         *error = RTE_NOCONDUCTOR;
 107                     }
 108
 109                     return FALSE;
 110                 }
 111             }
 112
 113             break;
 114
 115         case PLAYER_Conductor:
 116             if (tag->ti_Data == NULL)
 117             {
 118                 player->pl_Source = NULL;
 119             }
 120             else
 121             {
 122                 struct Conductor *conductor;
 123
 124                 lock = LockRealTime(RT_CONDUCTORS);
 125                 conductor = FindConductor((STRPTR)tag->ti_Data);
 126                 UnlockRealTime(lock);
 127
 128                 if (conductor == NULL)
 129                 {
 130                     if (error != NULL)
 131                     {
 132                         *error = RTE_NOCONDUCTOR;
 133                     }
 134
 135                     return FALSE;
 136                 }
 137             }
 138
 139             break;
 140
 141         case PLAYER_Ready:
 142             if ((BOOL)tag->ti_Data)
 143             {
 144                 struct Conductor *conductor = player->pl_Source;
 145
 146                 player->pl_Flags |= PLAYERF_READY;
 147
 148                 if (conductor != NULL)
 149                 {
 150                     ObtainSemaphoreShared(&conductor->cdt_Lock);
 151
 152                     if (conductor->cdt_Barrier != NULL)
 153                     {
 154                         Signal(conductor->cdt_Barrier, SIGF_SINGLE);
 155                     }
 156
 157                     ReleaseSemaphore(&conductor->cdt_Lock);
 158                 }
 159             }
 160             else
 161             {
 162                 player->pl_Flags &= ~PLAYERF_READY;
 163             }
 164
 165             break;
 166
 167         case PLAYER_AlarmTime:
 168             player->pl_Flags |= PLAYERF_ALARMSET;
 169             player->pl_AlarmTime = (LONG)tag->ti_Data;
 170             break;
 171
 172         case PLAYER_Alarm:
 173             if ((BOOL)tag->ti_Data)
 174             {
 175                 player->pl_Flags |= PLAYERF_ALARMSET;
 176             }
 177             else
 178             {
 179                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 180             }
 181
 182             break;
 183
 184         case PLAYER_AlarmSigTask:
 185             if ((struct Task *)tag->ti_Data == NULL)
 186             {
 187                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 188             }
 189
 190             player->pl_Task = (struct Task *)tag->ti_Data;
 191             break;
 192
 193         case PLAYER_AlarmSigBit:
 194             if ((BYTE)tag->ti_Data == -1)
 195             {
 196                 player->pl_Flags &= ~PLAYERF_ALARMSET;
 197             }
 198
 199             /* We could use player->pl_Link.ln_Type here */
 200             player->pl_Reserved0 = (BYTE)tag->ti_Data;      /* NOTE! */
 201             break;
 202
 203         case PLAYER_Quiet:
 204             if ((BOOL)tag->ti_Data)
 205             {
 206                 player->pl_Flags |= PLAYERF_QUIET;
 207             }
 208             else
 209             {
 210                 player->pl_Flags &= ~PLAYERF_QUIET;
 211             }
 212
 213             break;
 214
 215         case PLAYER_UserData:
 216             player->pl_UserData = (APTR)tag->ti_Data;
 217             break;
 218
 219         case PLAYER_ID:
 220             player->pl_PlayerID = (UWORD)tag->ti_Data;
 221             break;
 222
 223         case PLAYER_Conducted:
 224             if ((BOOL)tag->ti_Data)
 225             {
 226                 player->pl_Flags |= PLAYERF_CONDUCTED;
 227             }
 228             else
 229             {
 230                 player->pl_Flags &= ~PLAYERF_CONDUCTED;
 231             }
 232
 233             break;
 234
 235         case PLAYER_ExtSync:
 236             lock = LockRealTime(RT_CONDUCTORS);
 237
 238             if ((BOOL)tag->ti_Data)
 239             {
 240                 if (player->pl_Source->cdt_Flags & CONDUCTF_EXTERNAL)
 241                 {
 242                     /* Only one external synchronizer at a time, please */
 243                     UnlockRealTime(lock);
 244
 245                     return FALSE;
 246                 }
 247
 248                 player->pl_Source->cdt_Flags |= CONDUCTF_EXTERNAL;
 249                 player->pl_Flags |= PLAYERF_EXTSYNC;
 250             }
 251             else
 252             {
 253                 /* If this player was the external synchronizer, we
 254                    clean up */
 255                 if (player->pl_Flags & PLAYERF_EXTSYNC)
 256                 {
 257                     player->pl_Source->cdt_Flags &= ~CONDUCTF_EXTERNAL;
 258                     player->pl_Source->cdt_Flags &= ~CONDUCTF_GOTTICK;
 259                 }
 260
 261                 player->pl_Flags &= ~PLAYERF_EXTSYNC;
 262             }
 263
 264             UnlockRealTime(lock);
 265
 266             break;
 267         }
 268     }
 269
 270     /* Consistency checks */
 271     if (player->pl_Task == NULL)
 272     {
 273         player->pl_Flags &= ~PLAYERF_ALARMSET;
 274     }
 275
 276     return TRUE;
 277
 278     AROS_LIBFUNC_EXIT
 279 } /* SetPlayerAttrsA */